Open64: osprey/common/com/ia64/targ

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 /* ====================================================================
00037  * ====================================================================
00038  *
00039  * Module: targ_const.c
00040  * $Revision: 1.1.1.1 $
00041  * $Date: 2005/10/21 19:00:00 $
00042  * $Author: marcel $
00043  * $Source: /proj/osprey/CVS/open64/osprey1.0/common/com/ia64/targ_const.cxx,v $
00044  *
00045  * Revision history:
00046  *  12-Jun-91 - Original Version
00047  *
00048  * Description:
00049  *
00050  * Target constant handling.
00051  *
00052  * Routines in this file are supposed to do operations of compile time
00053  * constants in a host independent way.  There whould be one version of
00054  * this file for each <host, target> pair.  Using these routines, the
00055  * compiler should be able to guarantee that the same source will give
00056  * same object, no matter which machine the compiler is hosted on.
00057  *
00058  * TCON is a data type used to represent all scalar and string
00059  * compile-time constants.  Its internals should be visible only inside
00060  * this file.  To facilitate constant operations, we probably want to
00061  * keep constants in something resembling the host representation, but
00062  * that is not necessary for the rest of the compiler.  The routines
00063  * below must be consistent among  themselves in interpreting TCON and
00064  * doing operations on them.
00065  *
00066  * Theoretically rehosting the compiler to machines with different
00067  * byte-order or different floating point format should require changes
00068  * only to internal structure of TCON and to targ_const.c. It should
00069  * even be possible to keep constants in some kind of symbolic way and
00070  * do symbolic constant folding if the target representation is not
00071  * known to some phases of the  compiler.
00072  *
00073  * The rest of the compiler must not assume anything about internals of
00074  * TCON, except that it keeps the type of the constant within itself.
00075  * In particular, the size of TCON must not be assumed to related to
00076  * the size of the represented constant in any way.
00077  *
00078  * ====================================================================
00079  * ====================================================================
00080  */
00081 #define __STDC_LIMIT_MACROS
00082 #include <stdint.h>
00083 
00084 #define USE_STANDARD_TYPES 1
00085 #include <limits.h>
00086 #include <fp_class.h>
00087 #include "defs.h"
00088 #include "config.h"
00089 #include "config_asm.h"
00090 #include "erglob.h"
00091 #include "tracing.h"
00092 
00093 #include "mempool.h"
00094 #include "mtypes.h"
00095 #include "strtab.h"
00096 #include "opcode.h"
00097 #include "wintrinsic.h"
00098 #include "wn_core.h"
00099 #include "stab.h"
00100 #include "targ_const.h"
00101 #include "const.h"
00102 #include "quad.h"
00103 #include "quadsim.h"
00104 #include <math.h>
00105 
00106 /* For fp_class */
00107 
00108 #define DMANTWIDTH      52
00109 #define DEXPWIDTH       11
00110 #define DSIGNMASK       0x7fffffffffffffffll
00111 #define DEXPMASK        0x800fffffffffffffll
00112 #define DQNANBITMASK    0xfff7ffffffffffffll
00113 
00114 #define MANTWIDTH       23
00115 #define EXPWIDTH        8
00116 #define SIGNMASK        0x7fffffff
00117 #define EXPMASK         0x807fffff
00118 #define QNANBITMASK     0xffbfffff
00119 
00120 /* Just to make sure we have this, it should come from math.h */
00121 #ifndef M_PI
00122 #define M_PI 3.14159265358979323846
00123 #endif
00124 
00125 #define MIN_INT_I8  (((mINT64)1)<<(sizeof(mINT64)*8 - 1))
00126 #define MIN_INT_I4  (1<<(sizeof(mINT32)*8 - 1))
00127 #define MIN_INT_I2  (1<<(sizeof(mINT16)*8 - 1))
00128 
00129 /* results of comparisons */
00130 #define LOGICAL_MTYPE   MTYPE_U4
00131 
00132 #include "targ_const_private.h"
00133 
00134 #if defined(_COMPILER_VERSION) && (_COMPILER_VERSION >= 400) && _SGIAPI
00135 #define QUAD_PRECISION_SUPPORTED
00136 #else
00137 #undef QUAD_PRECISION_SUPPORTED
00138 #endif
00139 
00140 /*
00141 extern double atof(const char *);
00142 extern double sqrt(double);
00143 extern INT32 atoi(const char *);
00144 */
00145 
00146 /* This initailization must be static because it may be used
00147  * before first call to Targ_WhirlOp.  Also WARNING: It requires
00148  * that TCON_ty field be first one in TCON
00149  */
00150 TCON Zero_I4_Tcon = { MTYPE_I4 };
00151 TCON Zero_I8_Tcon = { MTYPE_I8 };
00152 TCON Quad_Zero_Tcon = { MTYPE_FQ };
00153 
00154 static TCON Targ_Ipower(TCON base, UINT64 exp, BOOL neg_exp, BOOL *folded, TYPE_ID btype);
00155 static TCON Targ_Power(TCON base, TCON exp, BOOL *folded, TYPE_ID btype);
00156 
00157 
00158 TCON Targ_Conv ( TYPE_ID ty_to, TCON c ); /* Defined later, used in Targ_WhirlOp */
00159 
00160 
00161 
00162 /* ====================================================================
00163  * This is the safe way of converting a QUAD_TYPE to a quad and vice
00164  * versa, and replaces:
00165  *
00166  *     #define TCON_RQ(c) (*((quad *)&(c).vals.dval))
00167  *
00168  * This #define may be fatal should a TCON have a smaller alignment 
00169  * than a quad. 
00170  * ====================================================================
00171 */
00172 typedef union QUAD_REPRESENTATION
00173 {
00174    QUAD_TYPE a_quadtype;
00175    QUAD      a_quad;
00176 #ifdef QUAD_PRECISION_SUPPORTED
00177    long double a_longdouble;
00178 #endif
00179 } Quad_Representation;
00180 
00181 static QUAD
00182 R16_To_RQ(QUAD_TYPE qt)
00183 {
00184    Quad_Representation repr;
00185    
00186    repr.a_quadtype = qt;
00187    return repr.a_quad;
00188 }
00189 
00190 static QUAD_TYPE
00191 RQ_To_R16(QUAD q)
00192 {
00193    Quad_Representation repr;
00194    
00195    repr.a_quad = q;
00196    return repr.a_quadtype;
00197 }
00198 
00199 #ifdef QUAD_PRECISION_SUPPORTED
00200 static long double
00201 R16_To_RLD(QUAD_TYPE qt)
00202 {
00203    Quad_Representation repr;
00204    
00205    repr.a_quadtype = qt;
00206    return repr.a_longdouble;
00207 }
00208 
00209 static QUAD_TYPE
00210 RLD_To_R16(long double q)
00211 {
00212    Quad_Representation repr;
00213    
00214    repr.a_longdouble = q;
00215    return repr.a_quadtype;
00216 }
00217 #endif
00218 
00219 #ifdef Is_True_On
00220 void
00221 Check_TCON ( TCON *tc )
00222 {
00223   switch (TCON_ty(*tc)) {
00224     case MTYPE_I1:
00225     case MTYPE_I2:
00226     case MTYPE_I4:
00227     case MTYPE_U1:
00228     case MTYPE_U2:
00229     case MTYPE_U4:
00230     case MTYPE_F4:
00231      Is_True ( TCON_v1(*tc)|TCON_v2(*tc)|TCON_v3(*tc) == 0,
00232          ("High order word of %s TCON non zero %x",
00233     Mtype_Name(TCON_ty(*tc)), TCON_v1(*tc)) );
00234      break;
00235     case MTYPE_I8:
00236     case MTYPE_U8:
00237     case MTYPE_F8:
00238      Is_True ( TCON_v2(*tc)|TCON_v3(*tc) == 0,
00239          ("High order word of %s TCON non zero %x",
00240     Mtype_Name(TCON_ty(*tc)), TCON_v1(*tc)) );
00241      break;
00242 #ifdef TARG_NEEDS_QUAD_OPS
00243     case MTYPE_FQ:
00244     {
00245      QUAD q = R16_To_RQ(TCON_R16(*tc));
00246      /*
00247        In Fortran, a user can specify an illegal quad constant
00248        using VMS-style bit constants, so we should just give
00249        a warning.
00250      */
00251      if ( q.hi == 0.0 && q.lo != 0.0)
00252       ErrMsg( EC_Ill_Quad_Const, TCON_u0(*tc), TCON_u1(*tc), TCON_u2(*tc), TCON_u3(*tc));
00253     }
00254      break;
00255 #endif
00256     default:
00257      break;
00258   }
00259 } /* Check_TCON */
00260 #endif /* Is_True_On */
00261 
00262 /*******************************************************************************
00263  * This is a set of routines for complex arithmetic on 
00264  * complex numbers. Much of this was lifted from libF77.a
00265  */
00266 
00267 static TCON complex_sqrt(TCON c0)
00268 {
00269    TCON r;
00270 
00271    TCON_clear(r);
00272    TCON_ty(r) = TCON_ty(c0);
00273 
00274    switch (TCON_ty(c0)) {
00275     case MTYPE_C4:
00276     {
00277       float fr,fi,fmag;
00278       fr = TCON_R4(c0);
00279       fi = TCON_IR4(c0);
00280       if( (fmag = hypotf(fr, fi)) == 0.)
00281   TCON_R4(r) = TCON_IR4(r) = 0.;
00282       else if (fr > 0) {
00283    TCON_R4(r) = sqrtf(0.5 * (fmag + fr) );
00284    TCON_IR4(r) = fi / TCON_R4(r) / 2;
00285       } else {
00286    TCON_IR4(r) = sqrtf(0.5 * (fmag - fr) );
00287    if (fi < 0) TCON_IR4(r) = -TCON_IR4(r);
00288    TCON_R4(r) = fi / TCON_IR4(r) /2;
00289       }
00290       break;
00291     }
00292     case MTYPE_C8:
00293     {
00294       double dr,di,dmag;
00295       dr = TCON_R8(c0);
00296       di = TCON_IR8(c0);
00297       if( (dmag = hypot(dr, di)) == 0.)
00298   TCON_R8(r) = TCON_IR8(r) = 0.;
00299       else if (dr > 0) {
00300    TCON_R8(r) = sqrt(0.5 * (dmag + dr) );
00301    TCON_IR8(r) = di / TCON_R8(r) / 2;
00302       } else {
00303    TCON_IR8(r) = sqrt(0.5 * (dmag - dr) );
00304    if (di < 0) TCON_IR8(r) = -TCON_IR8(r);
00305    TCON_R8(r) = di / TCON_IR8(r) /2;
00306       }
00307       break;
00308     }
00309     case MTYPE_C10:
00310     {
00311       long double ldr,ldi,ldmag;
00312       ldr = TCON_R16(c0);
00313       ldi = TCON_IR16(c0);
00314       if ((ldmag = hypotl(ldr, ldi)) == 0.0L)
00315   TCON_R16(r) = TCON_IR16(r) = 0.0L;
00316       else if (ldr > 0.0L) {
00317   TCON_R16(r) = sqrtl(0.5L * (ldmag + ldr));
00318   TCON_IR16(r) = ldi / TCON_R16(r) / 2.0L;
00319       } else {
00320   TCON_IR16(r) = sqrtl(0.5L * (ldmag - ldr));
00321   if (ldi < 0.0L)
00322     TCON_IR16(r) = -TCON_IR16(r);
00323   TCON_R16(r) = ldi / TCON_IR16(r) / 2.0L;
00324       }
00325       break;
00326     }
00327 
00328 #ifdef TARG_NEEDS_QUAD_OPS
00329     case MTYPE_CQ:
00330     {
00331       QUAD qr,qi,qmag,rqr,rqi,q0,q05;
00332       INT err;
00333       qr = R16_To_RQ(TCON_R16(c0));
00334       qi = R16_To_RQ(TCON_IR16(c0));
00335       q0 = __c_q_ext(0.0,&err);
00336       q05 = __c_q_ext(0.5,&err);
00337 
00338 #ifdef TODO_MONGOOSE
00339       /* This set of stuff needs to be re-written to make use of the
00340    qhypot function, when we figure out how to make it available*/
00341       /* qmag = qhypot(qr,qi); */
00342 #endif
00343       qmag = __c_q_sqrt(__c_q_add(__c_q_mul(qi,qi,&err),
00344           __c_q_mul(qr,qr,&err),
00345           &err),&err);
00346       if (__c_q_eq(qmag,q0,&err)) {
00347    rqr = q0;
00348    rqi = q0;
00349       }
00350       else if (__c_q_gt(qr,q0,&err)) {
00351    rqr = __c_q_sqrt(__c_q_mul(q05,__c_q_add(qmag,qr,&err),&err),&err);
00352    rqi = __c_q_mul(q05,__c_q_div(qi,rqr,&err),&err);
00353       } else {
00354    rqi = __c_q_sqrt(__c_q_mul(q05,__c_q_sub(qmag,qr,&err),&err),&err);
00355    if (__c_q_lt(qi,q0,&err)) rqi = __c_q_neg(rqi,&err);
00356    rqr = __c_q_mul(q05,__c_q_div(qi,rqi,&err),&err);
00357       }
00358       TCON_R16(r) = RQ_To_R16(rqr);
00359       TCON_IR16(r) = RQ_To_R16(rqi);
00360       break;
00361     }
00362 #endif
00363 
00364     default:
00365       ErrMsg ( EC_Inv_Mtype, Mtype_Name(TCON_ty(c0)), "complex_sqrt" );
00366    }
00367 
00368    return (r);
00369 }
00370 
00371 static TCON complex_divide(TCON c0, TCON c1)
00372 {
00373    TCON r;
00374 
00375    TCON_clear(r);
00376    TCON_ty(r) = TCON_ty(c0);
00377 
00378    switch (TCON_ty(c0)) {
00379     case MTYPE_C4:
00380       {
00381    float c0r,c0i,c1r,c1i,t1,t2,t3;
00382    c0r = TCON_R4(c0);
00383    c0i = TCON_IR4(c0);
00384    c1r = TCON_R4(c1);
00385    c1i = TCON_IR4(c1);
00386    if (fabsf(c1r) < fabsf(c1i)) {
00387       t2 = c1r*(c1r/c1i) + c1i;
00388       t1 = (c0i*(c1r/c1i) - c0r)/t2;
00389       t3 = (c0r*(c1r/c1i) + c0i)/t2;
00390    } else {
00391       t2 = c1i*(c1i/c1r) + c1r;
00392       t1 = (c0i - c0r*(c1i/c1r))/t2;
00393       t3 = (c0i*(c1i/c1r) + c0r)/t2;
00394    }      
00395    TCON_R4(r) = t3;
00396    TCON_IR4(r) = t1;
00397       }
00398       break;
00399       
00400     case MTYPE_C8:
00401       {
00402    double c0r,c0i,c1r,c1i,t1,t2,t3;
00403    c0r = TCON_R8(c0);
00404    c0i = TCON_IR8(c0);
00405    c1r = TCON_R8(c1);
00406    c1i = TCON_IR8(c1);
00407    if (fabs(c1r) < fabs(c1i)) {
00408       t2 = c1r*(c1r/c1i) + c1i;
00409       t1 = (c0i*(c1r/c1i) - c0r)/t2;
00410       t3 = (c0r*(c1r/c1i) + c0i)/t2;
00411    } else {
00412       t2 = c1i*(c1i/c1r) + c1r;
00413       t1 = (c0i - c0r*(c1i/c1r))/t2;
00414       t3 = (c0i*(c1i/c1r) + c0r)/t2;
00415    }      
00416    TCON_R8(r) = t3;
00417    TCON_IR8(r) = t1;
00418       }
00419       break;
00420  
00421     case MTYPE_C10:
00422     {
00423   long double c0r,c0i,c1r,c1i,t1,t2,t3;
00424   c0r = TCON_R16(c0);
00425   c0i = TCON_IR16(c0);
00426   c1r = TCON_R16(c1);
00427   c1i = TCON_IR16(c1);
00428   if (fabsl(c1r) < fabsl(c1i)) {
00429       t2 = c1r * (c1r / c1i) + c1i;
00430       t1 = (c0i * (c1r / c1i) - c0r) / t2;
00431       t3 = (c0r * (c1r / c1i) + c0i) / t2;
00432   } else {
00433       t2 = c1i * (c1i / c1r) + c1r;
00434       t1 = (c0i - c0r * (c1i / c1r)) / t2;
00435       t3 = (c0i * (c1i / c1r) + c0r) / t2;
00436   }
00437   TCON_R16(r) = t3;
00438   TCON_IR16(r) = t1;
00439   break;
00440     }
00441 
00442 #ifdef TARG_NEEDS_QUAD_OPS
00443     case MTYPE_CQ:
00444       {
00445    QUAD c0r,c0i,c1r,c1i,t1,t2,t3,t4,ar,ai,q0;
00446    INT err;
00447    q0 = __c_q_ext(0.0,&err);
00448    c0r = R16_To_RQ(TCON_R16(c0));
00449    c0i = R16_To_RQ(TCON_IR16(c0));
00450    c1r = R16_To_RQ(TCON_R16(c1));
00451    c1i = R16_To_RQ(TCON_IR16(c1));
00452    ar = c1r;
00453    ai = c1i;
00454    if (__c_q_lt(ar,q0,&err)) ar = __c_q_neg(ar,&err);
00455    if (__c_q_lt(ai,q0,&err)) ai = __c_q_neg(ai,&err);
00456    if (__c_q_lt(ar,ai,&err)) {
00457       t4 = __c_q_div(c1r,c1i,&err);
00458       t2 = __c_q_add(c1i,__c_q_mul(c1r,t4,&err),&err);
00459       t1 = __c_q_div(__c_q_sub(__c_q_mul(c0i,t4,&err),c0r,&err),
00460          t2,&err);
00461       t3 = __c_q_div(__c_q_add(__c_q_mul(c0r,t4,&err),c0i,&err),
00462          t2,&err);
00463    } else {
00464       t4 = __c_q_div(c1i,c1r,&err);
00465       t2 = __c_q_add(c1r,__c_q_mul(c1i,t4,&err),&err);
00466       t1 = __c_q_div(__c_q_sub(c0i,__c_q_mul(c0r,t4,&err),&err),
00467          t2,&err);
00468       t3 = __c_q_div(__c_q_add(__c_q_mul(c0i,t4,&err),c0r,&err),
00469          t2,&err);
00470    }      
00471    TCON_R16(r) = RQ_To_R16(t3);
00472    TCON_IR16(r) = RQ_To_R16(t1);
00473       }
00474       break;
00475 #endif
00476       
00477     default:
00478       ErrMsg ( EC_Inv_Mtype, Mtype_Name(TCON_ty(c0)), "complex_divide" );
00479    }
00480    
00481    return (r);
00482 }
00483 
00484 
00485 
00486 
00487 /* ====================================================================
00488  *
00489  * Targ_Convert_Length
00490  *
00491  * Convert the length of constants
00492  *
00493  * ====================================================================
00494  */
00495 
00496 static TCON
00497 Targ_Convert_Length (
00498   TCON  c0,   /* The constant to be converted */
00499   TCON  c1,   /* The source length for conversion */
00500   TYPE_ID mtype,  /* The result's MTYPE */
00501   INT16 len,    /* The result bit length */
00502   BOOL  sign )    /* Is the conversion signed? */
00503 {
00504   static const INT64 one = 1;
00505   INT64 sval = Targ_To_Host ( c0 );
00506   INT64 slen = Targ_To_Host ( c1 );
00507 
00508   /* If the source length is greater than the desired length, this is
00509    * a simple truncation:
00510    */
00511   if ( slen >= len ) {
00512     if ( len == 32 ) {
00513       mINT32 tval = sval & 0x0ffffffff;
00514       return Host_To_Targ ( mtype, tval );
00515     } else if ( len == 64 ) {
00516       return Host_To_Targ ( mtype, sval );
00517     } else {
00518       ErrMsg ( EC_Unimplemented, "Targ_Convert_Length: bad length 1" );
00519     }
00520   }
00521 
00522   if ( len == 32 ) {
00523     mINT32 highmask = (-1) << slen;
00524     mINT32 signmask = 1 << (slen-1);
00525     mINT32 tval = ( sval & ~highmask );
00526 
00527     if ( sign && ((tval & signmask) != 0) ) {
00528       tval |= highmask;
00529     }
00530     return Host_To_Targ ( mtype, tval );
00531 
00532   } else if ( len == 64 ) {
00533     INT64 highmask = (-one) << slen;
00534     INT64 signmask = one << (slen-1);
00535     INT64 tval = ( sval & ~highmask );
00536 
00537     if ( sign && ((tval & signmask) != 0) ) {
00538       tval |= highmask;
00539     }
00540     return Host_To_Targ ( mtype, tval );
00541 
00542   } else {
00543     ErrMsg ( EC_Unimplemented, "Targ_Convert_Length: bad length 2" );
00544     return c0;
00545   }
00546 
00547 } /* Targ_Convert_Length */
00548 
00549 
00550 
00551 /* ====================================================================
00552  *
00553  * Targ_WhirlOp
00554  *
00555  * Apply an WHIRL operator to TCON operands, yielding a TCON for the
00556  * result value.  The folded parameter, if non-NULL, is used to return
00557  * whether anything was done.
00558  *
00559  * It is an error to call this function with folded == NULL if in fact
00560  * nothing can be done (perhaps because the operator cannot be handed
00561  * yet).
00562  *
00563  * There are many call sites of Targ_WhirlOp with folded == NULL and
00564  * only a few with that check folded.  Is this right?
00565  *
00566  * TODO: Check the call sites of Targ_WhirlOp that have NULL folded
00567  * arguments to make sure they are doing the right thing.
00568  *
00569  * TODO Josie/92:  Install changes.
00570  *
00571  * ====================================================================
00572  */
00573 
00574 /************************************
00575 The latest word on BOTH_OPNDS: instead of complaining about the 
00576 operands being of different types, it should now coerce both operands
00577 to the type of the third argument. It should only do this for converts which
00578 are essentially NOPs however.
00579 
00580 **************************************/
00581 
00582 #define BOTH_OPNDS(op0,op1,type) \
00583 if (type != MTYPE_U8) { op0=Targ_Conv(type,op0);op1=Targ_Conv(type,op1); } \
00584 TCON_ty(op0)=type
00585 
00586 
00587 
00588 /* ====================================================================
00589  *
00590  * Targ_WhirlOp
00591  *
00592  * Given an SGIR operator (arithmetic) and one or two constant
00593  * operands, produce a constant expression result.  Some operators,
00594  * which can't always fold (e.g. division where the divisor might be
00595  * zero), will return an indicator in "folded" of whether they
00596  * succeeded; they generally take assertion failures if folded is NULL
00597  * and they can't fold.
00598  *
00599  * TODO:  Should these operators observe IEEE rules more completely,
00600  * e.g. returning NaN for min/max when one operand is NaN?
00601  *
00602  * ====================================================================
00603  */
00604 
00605 TCON
00606 Targ_WhirlOp ( OPCODE op, TCON c0, TCON c1, BOOL *folded )
00607 {
00608 #ifdef TARG_NEEDS_QUAD_OPS
00609    QUAD q0, q1;
00610    INT  err;
00611 #endif
00612    TCON t1, t2;
00613    TYPE_ID optype;
00614    BOOL dummy_folded;
00615   
00616 #ifdef Is_True_On
00617    Check_TCON (&c0);
00618    Check_TCON (&c1);
00619 #endif
00620 
00621 #undef DEBUG_FOLD
00622 #ifdef DEBUG_FOLD
00623    printf("Folding %s on 0x%llx (%s), 0x%llx (%s), result",OPCODE_name(op),
00624     TCON_I8(c0),Mtype_Name(TCON_ty(c0)),TCON_I8(c1),Mtype_Name(TCON_ty(c1)));
00625 #endif
00626 
00627    if (!folded) {
00628      folded = &dummy_folded;
00629    }
00630 
00631    *folded = TRUE;
00632    
00633    optype = OPCODE_rtype(op);
00634    TYPE_ID desc = OPCODE_desc(op);
00635    OPERATOR opr = OPCODE_operator(op);
00636 
00637    if (OPERATOR_is_compare(opr)) {
00638      if (MTYPE_is_integral(desc))
00639        BOTH_OPNDS(c0,c1,desc);
00640      switch (desc) {
00641        // the following is for case "desc=MTYPE_B", it will only be "1" and        // "0", but there is no macro to access this content, so only need to       // access this with TCON_I4.
00642        //TCON_I4(c) is defined as TCON_v0(c) in head file.
00643      case MTYPE_B: 
00644        switch (opr) {
00645          case OPR_EQ: TCON_I4(c0) = TCON_I4(c0) == TCON_I4(c1); break;
00646          case OPR_NE: TCON_I4(c0) = TCON_I4(c0) != TCON_I4(c1); break;
00647          case OPR_LT: TCON_I4(c0) = TCON_I4(c0) <  TCON_I4(c1); break;
00648          case OPR_LE: TCON_I4(c0) = TCON_I4(c0) <= TCON_I4(c1); break;
00649          case OPR_GT: TCON_I4(c0) = TCON_I4(c0) >  TCON_I4(c1); break;
00650          case OPR_GE: TCON_I4(c0) = TCON_I4(c0) >= TCON_I4(c1); break;
00651        } 
00652        break;
00653      case MTYPE_I4: 
00654        switch (opr) {
00655          case OPR_EQ: TCON_I4(c0) = TCON_I4(c0) == TCON_I4(c1); break;
00656          case OPR_NE: TCON_I4(c0) = TCON_I4(c0) != TCON_I4(c1); break;
00657          case OPR_LT: TCON_I4(c0) = TCON_I4(c0) <  TCON_I4(c1); break;
00658          case OPR_LE: TCON_I4(c0) = TCON_I4(c0) <= TCON_I4(c1); break;
00659          case OPR_GT: TCON_I4(c0) = TCON_I4(c0) >  TCON_I4(c1); break;
00660          case OPR_GE: TCON_I4(c0) = TCON_I4(c0) >= TCON_I4(c1); break;
00661        } 
00662        break;
00663      case MTYPE_U4: 
00664        switch (opr) {
00665          case OPR_EQ: TCON_I4(c0) = TCON_U4(c0) == TCON_U4(c1); break;
00666          case OPR_NE: TCON_I4(c0) = TCON_U4(c0) != TCON_U4(c1); break;
00667          case OPR_LT: TCON_I4(c0) = TCON_U4(c0) <  TCON_U4(c1); break;
00668          case OPR_LE: TCON_I4(c0) = TCON_U4(c0) <= TCON_U4(c1); break;
00669          case OPR_GT: TCON_I4(c0) = TCON_U4(c0) >  TCON_U4(c1); break;
00670          case OPR_GE: TCON_I4(c0) = TCON_U4(c0) >= TCON_U4(c1); break;
00671        } 
00672        break;
00673      case MTYPE_I8:
00674        switch (opr) {
00675    case OPR_EQ: TCON_v0(c0) = TCON_I8(c0) == TCON_I8(c1); break;
00676    case OPR_NE: TCON_v0(c0) = TCON_I8(c0) != TCON_I8(c1); break;
00677    case OPR_LT: TCON_v0(c0) = TCON_I8(c0) <  TCON_I8(c1); break;
00678    case OPR_LE: TCON_v0(c0) = TCON_I8(c0) <= TCON_I8(c1); break;
00679    case OPR_GT: TCON_v0(c0) = TCON_I8(c0) >  TCON_I8(c1); break;
00680    case OPR_GE: TCON_v0(c0) = TCON_I8(c0) >= TCON_I8(c1); break;
00681        }
00682        TCON_v1(c0) = 0;
00683        break;
00684      case MTYPE_U8:
00685        switch (opr) {
00686    case OPR_EQ: TCON_v0(c0) = TCON_U8(c0) == TCON_U8(c1); break;
00687    case OPR_NE: TCON_v0(c0) = TCON_U8(c0) != TCON_U8(c1); break;
00688    case OPR_LT: TCON_v0(c0) = TCON_U8(c0) <  TCON_U8(c1); break;
00689    case OPR_LE: TCON_v0(c0) = TCON_U8(c0) <= TCON_U8(c1); break;
00690    case OPR_GT: TCON_v0(c0) = TCON_U8(c0) >  TCON_U8(c1); break;
00691    case OPR_GE: TCON_v0(c0) = TCON_U8(c0) >= TCON_U8(c1); break;
00692        }
00693        TCON_v1(c0) = 0;
00694        break;
00695      case MTYPE_F4:
00696        switch (opr) {
00697    case OPR_EQ: TCON_v0(c0) = TCON_R4(c0) == TCON_R4(c1); break;
00698    case OPR_NE: TCON_v0(c0) = TCON_R4(c0) != TCON_R4(c1); break;
00699    case OPR_LT: TCON_v0(c0) = TCON_R4(c0) <  TCON_R4(c1); break;
00700    case OPR_LE: TCON_v0(c0) = TCON_R4(c0) <= TCON_R4(c1); break;
00701    case OPR_GT: TCON_v0(c0) = TCON_R4(c0) >  TCON_R4(c1); break;
00702    case OPR_GE: TCON_v0(c0) = TCON_R4(c0) >= TCON_R4(c1); break;
00703        }
00704        TCON_v1(c0) = 0;
00705        break;
00706      case MTYPE_F8:
00707        switch (opr) {
00708    case OPR_EQ: TCON_v0(c0) = TCON_R8(c0) == TCON_R8(c1); break;
00709    case OPR_NE: TCON_v0(c0) = TCON_R8(c0) != TCON_R8(c1); break;
00710    case OPR_LT: TCON_v0(c0) = TCON_R8(c0) <  TCON_R8(c1); break;
00711    case OPR_LE: TCON_v0(c0) = TCON_R8(c0) <= TCON_R8(c1); break;
00712    case OPR_GT: TCON_v0(c0) = TCON_R8(c0) >  TCON_R8(c1); break;
00713    case OPR_GE: TCON_v0(c0) = TCON_R8(c0) >= TCON_R8(c1); break;
00714        }
00715        TCON_v1(c0) = 0;
00716        break;
00717      case MTYPE_F10:
00718        switch (opr) {
00719          case OPR_EQ: TCON_v0(c0) = TCON_R16(c0) == TCON_R16(c1); break;
00720          case OPR_NE: TCON_v0(c0) = TCON_R16(c0) != TCON_R16(c1); break;
00721          case OPR_LT: TCON_v0(c0) = TCON_R16(c0) <  TCON_R16(c1); break;
00722          case OPR_LE: TCON_v0(c0) = TCON_R16(c0) <= TCON_R16(c1); break;
00723          case OPR_GT: TCON_v0(c0) = TCON_R16(c0) >  TCON_R16(c1); break;
00724          case OPR_GE: TCON_v0(c0) = TCON_R16(c0) >= TCON_R16(c1); break;
00725        }
00726        TCON_v1(c0) = 0;
00727        TCON_v2(c0) = 0;
00728        TCON_v3(c0) = 0;
00729        break;
00730 #ifdef TARG_NEEDS_QUAD_OPS
00731      case MTYPE_FQ:
00732        q0 = R16_To_RQ(TCON_R16(c0));
00733        q1 = R16_To_RQ(TCON_R16(c1));
00734        switch (opr) {
00735        case OPR_EQ: TCON_v0(c0) = __c_q_eq ( q0, q1, &err ); break;
00736        case OPR_NE: TCON_v0(c0) = __c_q_ne ( q0, q1, &err ); break;
00737        case OPR_LT: TCON_v0(c0) = __c_q_lt ( q0, q1, &err ); break;
00738        case OPR_LE: TCON_v0(c0) = __c_q_le ( q0, q1, &err ); break;
00739        case OPR_GT: TCON_v0(c0) = __c_q_gt ( q0, q1, &err ); break;
00740        case OPR_GE: TCON_v0(c0) = __c_q_ge ( q0, q1, &err ); break;
00741        }
00742        TCON_v1(c0) = 0;
00743        TCON_v2(c0) = 0;
00744        TCON_v3(c0) = 0;
00745        break;
00746 #endif
00747      case MTYPE_C4:
00748        switch (opr) {
00749        case OPR_EQ: TCON_v0(c0) = (TCON_R4(c0) == TCON_R4(c1)) && 
00750           (TCON_IR4(c0) == TCON_IR4(c1)); break; 
00751        case OPR_NE: TCON_v0(c0) = (TCON_R4(c0) != TCON_R4(c1)) || 
00752           (TCON_IR4(c0) != TCON_IR4(c1)); break; 
00753        }
00754        TCON_v1(c0) = 0;
00755        break;
00756      case MTYPE_C8:
00757        switch (opr) {
00758        case OPR_EQ: TCON_v0(c0) = (TCON_R8(c0) == TCON_R8(c1)) && 
00759           (TCON_IR8(c0) == TCON_IR8(c1)); break; 
00760        case OPR_NE: TCON_v0(c0) = (TCON_R8(c0) != TCON_R8(c1)) || 
00761           (TCON_IR8(c0) != TCON_IR8(c1)); break; 
00762        }
00763        TCON_v1(c0) = 0;
00764        break;
00765     case MTYPE_C10:
00766   switch (opr) {
00767   case OPR_EQ:
00768       TCON_v0(c0) = (TCON_R16(c0) == TCON_R16(c1) &&
00769          TCON_IR16(c0) == TCON_IR16(c1));
00770       break;
00771   case OPR_NE:
00772       TCON_v0(c0) = (TCON_R16(c0) != TCON_R16(c1) ||
00773          TCON_IR16(c0) != TCON_IR16(c1));
00774       break;
00775   }
00776   TCON_v1(c0) = 0;
00777   TCON_v2(c0) = 0;
00778   TCON_v3(c0) = 0;
00779   break;
00780 #ifdef TARG_NEEDS_QUAD_OPS
00781      case MTYPE_CQ:
00782        q0 = R16_To_RQ(TCON_R16(c0));
00783        q1 = R16_To_RQ(TCON_R16(c1));
00784        switch (opr) {
00785        case OPR_EQ: TCON_v0(c0) = __c_q_eq ( q0, q1, &err ); break;
00786        case OPR_NE: TCON_v0(c0) = __c_q_ne ( q0, q1, &err ); break;
00787        }
00788        q0 = R16_To_RQ(TCON_IR16(c0));
00789        q1 = R16_To_RQ(TCON_IR16(c1));
00790        switch (opr) {
00791        case OPR_EQ: TCON_v0(c0) &= __c_q_eq ( q0, q1, &err ); break;
00792        case OPR_NE: TCON_v0(c0) |= __c_q_ne ( q0, q1, &err ); break;
00793        }
00794        TCON_v1(c0) = 0;
00795        TCON_v2(c0) = 0;
00796        TCON_v3(c0) = 0;
00797        break;
00798 #endif
00799      }
00800      TCON_ty(c0) = optype;
00801    }
00802    else 
00803    switch (op) {
00804 
00805     case OPC_F4PAREN:
00806     case OPC_F8PAREN:
00807     case OPC_F10PAREN:
00808     case OPC_FQPAREN:
00809     case OPC_C4PAREN:
00810     case OPC_C8PAREN:
00811 #ifdef TARG_IA64
00812     case OPC_C10PAREN: 
00813 #endif
00814     case OPC_CQPAREN:
00815       /* just c0 */
00816       break;
00817 
00818 
00819     case OPC_I8CVTL:
00820       c0 = Targ_Convert_Length(c0,c1,MTYPE_I8,64,TRUE);
00821       break;
00822     case OPC_I4CVTL:
00823       c0 = Targ_Convert_Length(c0,c1,MTYPE_I4,32,TRUE);
00824       break;
00825     case OPC_U8CVTL:
00826       c0 = Targ_Convert_Length(c0,c1,MTYPE_U8,64,FALSE);
00827       break;
00828     case OPC_U4CVTL:
00829       c0 = Targ_Convert_Length(c0,c1,MTYPE_U4,32,FALSE);
00830       break;
00831 
00832     /* For shift cases read ANSI/ISO 9899-1990 standard, Section 6.3.7.
00833        The type of the shift is that of the left operand. The right operand
00834        type can actually be larger than the left. The TCON_I8U8I4U4
00835        macro handles this (any other combination will have a CVT inserted).
00836 
00837        For shift amounts that are greater than the width of the bits in
00838        the left operand, the behavior on IA64 is defined as: 
00839           1) The shift count is interperted as an unsigned number
00840           2) If the value of the shift count is greater than the word size,
00841               the result is all zero (left shifts and logical right shift) or
00842               a word filled with the sign bit (arithmetic right shift).
00843     */
00844     case OPC_I8SHL:
00845     case OPC_U8SHL:
00846       c0 = Targ_Conv(optype, c0);
00847       if ((TCON_I8U8I4U4(c1) >= 0) && (TCON_I8U8I4U4(c1) <= 63)) {
00848         TCON_I8(c0) <<= TCON_I8U8I4U4(c1);
00849       } else {
00850         TCON_I8(c0) = 0;
00851       }
00852       break;
00853     case OPC_I4SHL:
00854     case OPC_U4SHL:
00855       c0 = Targ_Conv(optype, c0);
00856       if ((TCON_I8U8I4U4(c1) >= 0) && (TCON_I8U8I4U4(c1) <= 31)) {
00857         TCON_I4(c0) <<= TCON_I8U8I4U4(c1);
00858       } else {
00859         TCON_I4(c0) = 0;
00860       }
00861       break;
00862 
00863     case OPC_I8LSHR:
00864     case OPC_U8LSHR:
00865       c0 = Targ_Conv(optype, c0);
00866       if ((TCON_I8U8I4U4(c1) >= 0) && (TCON_I8U8I4U4(c1) <= 63)) {
00867         TCON_U8(c0) >>= TCON_I8U8I4U4(c1);
00868       } else {
00869         TCON_U8(c0) = 0;
00870       }
00871       break;
00872     case OPC_I4LSHR:
00873     case OPC_U4LSHR:
00874       c0 = Targ_Conv(optype, c0);
00875       if ((TCON_I8U8I4U4(c1) >= 0) && (TCON_I8U8I4U4(c1) <= 31)) {
00876         TCON_U4(c0) >>= TCON_I8U8I4U4(c1);
00877       } else {
00878         TCON_U4(c0) = 0;
00879       }
00880       break;
00881 
00882     case OPC_I8ASHR:
00883     case OPC_U8ASHR:
00884       c0 = Targ_Conv(optype, c0);
00885       TCON_I8(c0) >>= ((TCON_I8U8I4U4(c1) >= 0) && (TCON_I8U8I4U4(c1) <= 63)) ? TCON_I8U8I4U4(c1) : 63;
00886       break;
00887     case OPC_I4ASHR:
00888     case OPC_U4ASHR:
00889       c0 = Targ_Conv(optype, c0);
00890       TCON_I4(c0) >>= ((TCON_I8U8I4U4(c1) >= 0) && (TCON_I8U8I4U4(c1) <= 31)) ? TCON_I8U8I4U4(c1) : 31;
00891       break;
00892 
00893     case OPC_F4F8CVT:
00894       Is_True(TCON_ty(c0) == MTYPE_F8, ("Illegal operand to %s", OPCODE_name(op)));
00895       c0 = Targ_Conv(MTYPE_F4, c0);
00896       break;
00897     case OPC_F8F4CVT:
00898       Is_True(TCON_ty(c0) == MTYPE_F4, ("Illegal operand to %s", OPCODE_name(op)));
00899       c0 = Targ_Conv(MTYPE_F8, c0);
00900       break;
00901 
00902     case OPC_F10F8CVT:
00903     case OPC_F10F4CVT:
00904       c0 = Targ_Conv(MTYPE_F10, c0);
00905       break;
00906     case OPC_F4F10CVT:
00907       c0 = Targ_Conv(MTYPE_F4, c0);
00908       break;
00909     case OPC_F8F10CVT:
00910       c0 = Targ_Conv(MTYPE_F8, c0);
00911       break;
00912 
00913 #ifdef TARG_NEEDS_QUAD_OPS
00914     case OPC_FQF4CVT:
00915       Is_True(TCON_ty(c0) == MTYPE_F4, ("Illegal operand to %s", OPCODE_name(op)));
00916       c0 = Targ_Conv(MTYPE_FQ, c0);
00917       break;
00918     case OPC_F4FQCVT:
00919       Is_True(TCON_ty(c0) == MTYPE_FQ, ("Illegal operand to %s", OPCODE_name(op)));
00920       c0 = Targ_Conv(MTYPE_F4, c0);
00921       break;
00922     case OPC_FQF8CVT:
00923       Is_True(TCON_ty(c0) == MTYPE_F8, ("Illegal operand to %s", OPCODE_name(op)));
00924       c0 = Targ_Conv(MTYPE_FQ, c0);
00925       break;
00926     case OPC_F8FQCVT:
00927       Is_True(TCON_ty(c0) == MTYPE_FQ, ("Illegal operand to %s", OPCODE_name(op)));
00928       c0 = Targ_Conv(MTYPE_F8, c0);
00929       break;
00930 #endif
00931 
00932     case OPC_I4F4CVT:
00933       Is_True(TCON_ty(c0) == MTYPE_F4, ("Illegal operand to %s", OPCODE_name(op)));
00934       c0 = Targ_Conv(MTYPE_I4, c0);
00935       break;
00936     case OPC_I4F8CVT:
00937       Is_True(TCON_ty(c0) == MTYPE_F8, ("Illegal operand to %s", OPCODE_name(op)));
00938       c0 = Targ_Conv(MTYPE_I4, c0);
00939       break;
00940     case OPC_I4F10CVT:
00941       c0 = Targ_Conv(MTYPE_I4, c0);
00942       break;
00943 
00944 #ifdef TARG_NEEDS_QUAD_OPS
00945     case OPC_I4FQCVT:
00946       Is_True(TCON_ty(c0) == MTYPE_FQ, ("Illegal operand to %s", OPCODE_name(op)));
00947       c0 = Targ_Conv(MTYPE_I4, c0);
00948       break;
00949 #endif
00950 
00951     case OPC_I8F4CVT:
00952       Is_True(TCON_ty(c0) == MTYPE_F4, ("Illegal operand to %s", OPCODE_name(op)));
00953       c0 = Targ_Conv(MTYPE_I8, c0);
00954       break;
00955     case OPC_I8F8CVT:
00956       Is_True(TCON_ty(c0) == MTYPE_F8, ("Illegal operand to %s", OPCODE_name(op)));
00957       c0 = Targ_Conv(MTYPE_I8, c0);
00958       break;
00959     case OPC_I8F10CVT:
00960       c0 = Targ_Conv(MTYPE_I8, c0);
00961       break;
00962 
00963 #ifdef TARG_NEEDS_QUAD_OPS
00964     case OPC_I8FQCVT:
00965       Is_True(TCON_ty(c0) == MTYPE_FQ, ("Illegal operand to %s", OPCODE_name(op)));
00966       c0 = Targ_Conv(MTYPE_I8, c0);
00967       break;
00968 #endif
00969 
00970     case OPC_U4F4CVT:
00971       Is_True(TCON_ty(c0) == MTYPE_F4, ("Illegal operand to %s", OPCODE_name(op)));
00972       c0 = Targ_Conv(MTYPE_U4, c0);
00973       break;
00974     case OPC_U4F8CVT:
00975       Is_True(TCON_ty(c0) == MTYPE_F8, ("Illegal operand to %s", OPCODE_name(op)));
00976       c0 = Targ_Conv(MTYPE_U4, c0);
00977       break;
00978     case OPC_U4F10CVT:
00979       c0 = Targ_Conv(MTYPE_U4, c0);
00980       break;
00981 
00982 #ifdef TARG_NEEDS_QUAD_OPS
00983     case OPC_U4FQCVT:
00984       Is_True(TCON_ty(c0) == MTYPE_FQ, ("Illegal operand to %s", OPCODE_name(op)));
00985       c0 = Targ_Conv(MTYPE_U4, c0);
00986       break;
00987 #endif     
00988 
00989     case OPC_U8F4CVT:
00990       Is_True(TCON_ty(c0) == MTYPE_F4, ("Illegal operand to %s", OPCODE_name(op)));
00991       c0 = Targ_Conv(MTYPE_U8, c0);
00992       break;
00993     case OPC_U8F8CVT:
00994       Is_True(TCON_ty(c0) == MTYPE_F8, ("Illegal operand to %s", OPCODE_name(op)));
00995       c0 = Targ_Conv(MTYPE_U8, c0);
00996       break;
00997     case OPC_U8F10CVT:
00998       c0 = Targ_Conv(MTYPE_U8, c0);
00999       break;
01000 
01001 #ifdef TARG_NEEDS_QUAD_OPS
01002     case OPC_U8FQCVT:
01003       Is_True(TCON_ty(c0) == MTYPE_FQ, ("Illegal operand to %s", OPCODE_name(op)));
01004       c0 = Targ_Conv(MTYPE_U8, c0);
01005       break;
01006 #endif
01007 
01008     case OPC_I8I4CVT:
01009     case OPC_I8U4CVT:
01010     case OPC_U8I4CVT:
01011     case OPC_U8U4CVT:
01012     case OPC_I4I8CVT:
01013     case OPC_I4U8CVT:
01014     case OPC_U4I8CVT:
01015     case OPC_U4U8CVT:
01016     case OPC_I8BCVT:
01017     case OPC_U8BCVT:
01018     case OPC_I4BCVT:
01019     case OPC_U4BCVT:
01020       c0 = Targ_Conv(OPCODE_desc(op),c0);
01021       c0 = Targ_Conv(optype, c0);
01022       break;
01023 
01024     case OPC_I4F8RND:
01025       if (TCON_R8(c0) >= 0.0) {
01026   TCON_I4(c0) = (INT32)(TCON_R8(c0) + 0.5);
01027       } else {
01028   TCON_I4(c0) = (INT32)(TCON_R8(c0) - 0.5);
01029       }
01030       TCON_v1(c0) = 0;
01031       TCON_ty(c0) = MTYPE_I4;
01032       break;
01033     case OPC_I4F4RND:
01034       if (TCON_R4(c0) >= 0.0) {
01035   TCON_I4(c0) = (INT32)(TCON_R4(c0) + 0.5);
01036       } else {
01037   TCON_I4(c0) = (INT32)(TCON_R4(c0) - 0.5);
01038       }
01039       TCON_v1(c0) = 0;
01040       TCON_ty(c0) = MTYPE_I4;
01041       break;
01042     case OPC_I4F10RND:
01043       if (TCON_R16(c0) >= 0.0) {
01044         TCON_I4(c0) = (INT32)(TCON_R16(c0) + 0.5);
01045       } else {
01046         TCON_I4(c0) = (INT32)(TCON_R16(c0) - 0.5);
01047       }
01048       TCON_v1(c0) = 0;
01049       TCON_v2(c0) = 0;
01050       TCON_v3(c0) = 0;
01051       TCON_ty(c0) = MTYPE_I4;
01052       break;
01053 
01054 #ifdef TARG_NEEDS_QUAD_OPS
01055     case OPC_I4FQRND:
01056       if (__c_q_ge(R16_To_RQ(TCON_R16(c0)), 
01057        __c_q_flotj(0, &err), 
01058        &err))
01059   TCON_R16(c0) = RQ_To_R16(__c_q_add(R16_To_RQ(TCON_R16(c0)), 
01060              __c_q_ext(.5, &err),
01061              &err));
01062       else
01063   TCON_R16(c0) = RQ_To_R16(__c_q_sub(R16_To_RQ(TCON_R16(c0)), 
01064              __c_q_ext(.5, &err),
01065              &err));
01066      
01067       c0 = Targ_Conv(MTYPE_I4,c0);
01068       break;
01069 #endif
01070      
01071     case OPC_I8F8RND:
01072       if (TCON_R8(c0) >= 0.0) {
01073   TCON_I8(c0) = (INT64)(TCON_R8(c0) + 0.5);
01074       } else {
01075   TCON_I8(c0) = (INT64)(TCON_R8(c0) - 0.5);
01076       }
01077       TCON_ty(c0) = MTYPE_I8;
01078       break;
01079     case OPC_I8F4RND:
01080       if (TCON_R4(c0) >= 0.0) {
01081   TCON_I8(c0) = (INT64)(TCON_R4(c0) + 0.5);
01082       } else {
01083   TCON_I8(c0) = (INT64)(TCON_R4(c0) - 0.5);
01084       }
01085       TCON_ty(c0) = MTYPE_I8;
01086       break;
01087     case OPC_I8F10RND:
01088       if (TCON_R16(c0) >= 0.0) {
01089         TCON_I8(c0) = (INT64)(TCON_R16(c0) + 0.5);
01090       } else {
01091         TCON_I8(c0) = (INT64)(TCON_R16(c0) - 0.5);
01092       }
01093       TCON_v2(c0) = 0;
01094       TCON_v3(c0) = 0;
01095       TCON_ty(c0) = MTYPE_I8;
01096       break;
01097 
01098 #ifdef TARG_NEEDS_QUAD_OPS
01099     case OPC_I8FQRND:
01100       if (__c_q_ge(R16_To_RQ(TCON_R16(c0)), 
01101        __c_q_flotj(0, &err), 
01102        &err))
01103   TCON_R16(c0) = RQ_To_R16(__c_q_add(R16_To_RQ(TCON_R16(c0)), 
01104              __c_q_ext(.5, &err),
01105              &err));
01106       else
01107   TCON_R16(c0) = RQ_To_R16(__c_q_sub(R16_To_RQ(TCON_R16(c0)), 
01108              __c_q_ext(.5, &err),
01109              &err));
01110      
01111       c0 = Targ_Conv(MTYPE_I8,c0);
01112       break;
01113 #endif
01114 
01115       /* Handle truncation like C style CVT ops, i.e. with Targ_Conv() */
01116     case OPC_I4F4TRUNC:
01117       Is_True(TCON_ty(c0) == MTYPE_F4, ("Illegal operand to %s", OPCODE_name(op)));
01118       c0 = Targ_Conv(MTYPE_I4, c0);
01119       break;
01120     case OPC_I4F8TRUNC:
01121       Is_True(TCON_ty(c0) == MTYPE_F8, ("Illegal operand to %s", OPCODE_name(op)));
01122       c0 = Targ_Conv(MTYPE_I4, c0);
01123       break;
01124     case OPC_I4F10TRUNC:
01125       c0 = Targ_Conv(MTYPE_I4, c0);
01126       break;
01127 
01128 #ifdef TARG_NEEDS_QUAD_OPS
01129     case OPC_I4FQTRUNC:
01130       Is_True(TCON_ty(c0) == MTYPE_FQ, ("Illegal operand to %s", OPCODE_name(op)));
01131       c0 = Targ_Conv(MTYPE_I4, c0);
01132       break;
01133 #endif
01134 
01135     case OPC_I8F4TRUNC:
01136       Is_True(TCON_ty(c0) == MTYPE_F4, ("Illegal operand to %s", OPCODE_name(op)));
01137       c0 = Targ_Conv(MTYPE_I8, c0);
01138       break;
01139     case OPC_I8F8TRUNC:
01140       Is_True(TCON_ty(c0) == MTYPE_F8, ("Illegal operand to %s", OPCODE_name(op)));
01141       c0 = Targ_Conv(MTYPE_I8, c0);
01142       break;
01143     case OPC_I8F10TRUNC:
01144       c0 = Targ_Conv(MTYPE_I8, c0);
01145       break;
01146 
01147 #ifdef TARG_NEEDS_QUAD_OPS
01148     case OPC_I8FQTRUNC:
01149       Is_True(TCON_ty(c0) == MTYPE_FQ, ("Illegal operand to %s", OPCODE_name(op)));
01150       c0 = Targ_Conv(MTYPE_I8, c0);
01151       break;
01152 #endif
01153 
01154 
01155     case OPC_I4F4FLOOR:
01156       t1 = Targ_Conv(MTYPE_I4, c0);
01157       t2 = Targ_Conv(MTYPE_F4, t1);
01158       if (TCON_R4(t2) > TCON_R4(c0)) {
01159    TCON_I4(t1) -= 1;
01160       }
01161       c0 = t1;
01162       break;
01163     case OPC_I4F8FLOOR:
01164       t1 = Targ_Conv(MTYPE_I4, c0);
01165       t2 = Targ_Conv(MTYPE_F8, t1);
01166       if (TCON_R8(t2) > TCON_R8(c0)) {
01167    TCON_I4(t1) -= 1;
01168       }
01169       c0 = t1;
01170       break;
01171     case OPC_I4F10FLOOR:
01172       t1 = Targ_Conv(MTYPE_I4, c0);
01173       t2 = Targ_Conv(MTYPE_F10, t1);
01174       if (TCON_R16(t2) > TCON_R16(c0)) {
01175          TCON_I4(t1) -= 1;
01176       }
01177       c0 = t1;
01178       break;
01179 
01180 #ifdef TARG_NEEDS_QUAD_OPS
01181     case OPC_I4FQFLOOR:
01182       t1 = Targ_Conv(MTYPE_I4, c0);
01183       t2 = Targ_Conv(MTYPE_FQ,t1);
01184       if (__c_q_gt(R16_To_RQ(TCON_R16(t2)),R16_To_RQ(TCON_R16(c0)),&err)) {
01185    TCON_I4(t1) -= 1;
01186       }
01187       c0 = t1;
01188       break;
01189 #endif
01190 
01191     case OPC_I8F4FLOOR:
01192       t1 = Targ_Conv(MTYPE_I8, c0);
01193       t2 = Targ_Conv(MTYPE_F4, t1);
01194       if (TCON_R4(t2) > TCON_R4(c0)) {
01195    TCON_I8(t1) -= 1;
01196       }
01197       c0 = t1;
01198       break;
01199     case OPC_I8F8FLOOR:
01200       t1 = Targ_Conv(MTYPE_I8, c0);
01201       t2 = Targ_Conv(MTYPE_F8, t1);
01202       if (TCON_R8(t2) > TCON_R8(c0)) {
01203    TCON_I8(t1) -= 1;
01204       }
01205       c0 = t1;
01206       break;
01207     case OPC_I8F10FLOOR:
01208       t1 = Targ_Conv(MTYPE_I8, c0);
01209       t2 = Targ_Conv(MTYPE_F10, t1);
01210       if (TCON_R16(t2) > TCON_R16(c0)) {
01211          TCON_I8(t1) -= 1;
01212       }
01213       c0 = t1;
01214       break;
01215 
01216 #ifdef TARG_NEEDS_QUAD_OPS
01217     case OPC_I8FQFLOOR:
01218       t1 = Targ_Conv(MTYPE_I8, c0);
01219       t2 = Targ_Conv(MTYPE_FQ,t1);
01220       if (__c_q_gt(R16_To_RQ(TCON_R16(t2)),R16_To_RQ(TCON_R16(c0)),&err)) {
01221    TCON_I8(t1) -= 1;
01222       }
01223       c0 = t1;
01224       break;
01225 #endif
01226 
01227     case OPC_I4F4CEIL:
01228       t1 = Targ_Conv(MTYPE_I4, c0);
01229       t2 = Targ_Conv(MTYPE_F4, t1);
01230       if (TCON_R4(t2) < TCON_R4(c0)) {
01231    TCON_I4(t1) += 1;
01232       }
01233       c0 = t1;
01234       break;
01235     case OPC_I4F8CEIL:
01236       t1 = Targ_Conv(MTYPE_I4, c0);
01237       t2 = Targ_Conv(MTYPE_F8, t1);
01238       if (TCON_R8(t2) < TCON_R8(c0)) {
01239    TCON_I4(t1) += 1;
01240       }
01241       c0 = t1;
01242       break;
01243     case OPC_I4F10CEIL:
01244       t1 = Targ_Conv(MTYPE_I4, c0);
01245       t2 = Targ_Conv(MTYPE_F10, t1);
01246       if (TCON_R16(t2) < TCON_R16(c0)) {
01247          TCON_I4(t1) += 1;
01248       }
01249       c0 = t1;
01250       break;
01251 
01252 #ifdef TARG_NEEDS_QUAD_OPS
01253     case OPC_I4FQCEIL:
01254       t1 = Targ_Conv(MTYPE_I4, c0);
01255       t2 = Targ_Conv(MTYPE_FQ,t1);
01256       if (__c_q_lt(R16_To_RQ(TCON_R16(t2)),R16_To_RQ(TCON_R16(c0)),&err)) {
01257    TCON_I4(t1) += 1;
01258       }
01259       c0 = t1;
01260       break;
01261 #endif
01262 
01263     case OPC_I8F4CEIL:
01264       t1 = Targ_Conv(MTYPE_I8, c0);
01265       t2 = Targ_Conv(MTYPE_F4,t1);
01266       if (TCON_R4(t2) < TCON_R4(c0)) {
01267    TCON_I8(t1) += 1;
01268       }
01269       c0 = t1;
01270       break;
01271     case OPC_I8F8CEIL:
01272       t1 = Targ_Conv(MTYPE_I8, c0);
01273       t2 = Targ_Conv(MTYPE_F8,t1);
01274       if (TCON_R8(t2) < TCON_R8(c0)) {
01275    TCON_I8(t1) += 1;
01276       }
01277       c0 = t1;
01278       break;
01279     case OPC_I8F10CEIL:
01280       t1 = Targ_Conv(MTYPE_I8, c0);
01281       t2 = Targ_Conv(MTYPE_F10, t1);
01282       if (TCON_R16(t2) < TCON_R16(c0)) {
01283          TCON_I8(t1) += 1;
01284       }
01285       c0 = t1;
01286       break;
01287 
01288 #ifdef TARG_NEEDS_QUAD_OPS
01289     case OPC_I8FQCEIL:
01290       t1 = Targ_Conv(MTYPE_I8, c0);
01291       t2 = Targ_Conv(MTYPE_FQ,t1);
01292       if (__c_q_lt(R16_To_RQ(TCON_R16(t2)),R16_To_RQ(TCON_R16(c0)),&err)) {
01293    TCON_I8(t1) += 1;
01294       }
01295       c0 = t1;
01296       break;
01297 #endif
01298 
01299     case OPC_U4F8RND:
01300       TCON_U4(c0) = (UINT32)(TCON_R8(c0) + 0.5);
01301       TCON_v1(c0) = 0;
01302       TCON_ty(c0) = MTYPE_U4;
01303       break;
01304     case OPC_U4F4RND:
01305       TCON_U4(c0) = (UINT32)(TCON_R4(c0) + 0.5);
01306       TCON_ty(c0) = MTYPE_U4;
01307       break;
01308     case OPC_U4F10RND:
01309       TCON_U4(c0) = (UINT32)(TCON_R16(c0) + 0.5);
01310       TCON_v1(c0) = 0;
01311       TCON_v2(c0) = 0;
01312       TCON_v3(c0) = 0;
01313       TCON_ty(c0) = MTYPE_U4;
01314       break;
01315 
01316 #ifdef TARG_NEEDS_QUAD_OPS
01317     case OPC_U4FQRND:
01318       TCON_R16(c0) = RQ_To_R16(__c_q_add(R16_To_RQ(TCON_R16(c0)), 
01319            __c_q_ext(.5, &err),
01320            &err));
01321       c0 = Targ_Conv(MTYPE_U4,c0);
01322       break;
01323 #endif
01324 
01325     case OPC_U8F8RND:
01326       TCON_U8(c0) = (UINT64)(TCON_R8(c0) + 0.5);
01327       TCON_ty(c0) = MTYPE_U8;
01328       break;
01329     case OPC_U8F4RND:
01330       TCON_U8(c0) = (UINT64)(TCON_R4(c0) + 0.5);
01331       TCON_ty(c0) = MTYPE_U8;
01332       break;
01333     case OPC_U8F10RND:
01334       TCON_U8(c0) = (UINT64)(TCON_R16(c0) + 0.5);
01335       TCON_v2(c0) = 0;
01336       TCON_v3(c0) = 0;
01337       TCON_ty(c0) = MTYPE_U8;
01338       break;
01339 
01340 #ifdef TARG_NEEDS_QUAD_OPS
01341     case OPC_U8FQRND:
01342       TCON_R16(c0) = RQ_To_R16(__c_q_add(R16_To_RQ(TCON_R16(c0)), 
01343              __c_q_ext(.5, &err),
01344              &err));
01345       c0 = Targ_Conv(MTYPE_U8,c0);
01346       break;
01347 #endif
01348      
01349     case OPC_U4F4FLOOR:
01350     case OPC_U4F4TRUNC:
01351       Is_True(TCON_ty(c0) == MTYPE_F4, ("Illegal operand to %s", OPCODE_name(op)));
01352       c0 = Targ_Conv(MTYPE_U4, c0);
01353       break;
01354     case OPC_U4F8FLOOR:
01355     case OPC_U4F8TRUNC:
01356       Is_True(TCON_ty(c0) == MTYPE_F8, ("Illegal operand to %s", OPCODE_name(op)));
01357       c0 = Targ_Conv(MTYPE_U4, c0);
01358       break;
01359     case OPC_U4F10FLOOR:
01360     case OPC_U4F10TRUNC:
01361       c0 = Targ_Conv(MTYPE_U4, c0);
01362       break;
01363 
01364 #ifdef TARG_NEEDS_QUAD_OPS
01365     case OPC_U4FQFLOOR:
01366     case OPC_U4FQTRUNC:
01367       Is_True(TCON_ty(c0) == MTYPE_FQ, ("Illegal operand to %s", OPCODE_name(op)));
01368       c0 = Targ_Conv(MTYPE_U4, c0);
01369       break;
01370 #endif
01371 
01372     case OPC_U8F4FLOOR:
01373     case OPC_U8F4TRUNC:
01374       Is_True(TCON_ty(c0) == MTYPE_F4, ("Illegal operand to %s", OPCODE_name(op)));
01375       c0 = Targ_Conv(MTYPE_U8, c0);
01376       break;
01377     case OPC_U8F8FLOOR:
01378     case OPC_U8F8TRUNC:
01379       Is_True(TCON_ty(c0) == MTYPE_F8, ("Illegal operand to %s", OPCODE_name(op)));
01380       c0 = Targ_Conv(MTYPE_U8, c0);
01381       break;
01382     case OPC_U8F10FLOOR:
01383     case OPC_U8F10TRUNC:
01384       c0 = Targ_Conv(MTYPE_U8, c0);
01385       break;
01386 
01387 #ifdef TARG_NEEDS_QUAD_OPS
01388     case OPC_U8FQFLOOR:
01389     case OPC_U8FQTRUNC:
01390       Is_True(TCON_ty(c0) == MTYPE_FQ, ("Illegal operand to %s", OPCODE_name(op)));
01391       c0 = Targ_Conv(MTYPE_U8, c0);
01392       break;
01393 #endif
01394 
01395     case OPC_U4F4CEIL:
01396       t1 = Targ_Conv(MTYPE_U4, c0);
01397       t2 = Targ_Conv(MTYPE_F4,t1);
01398       if (TCON_R4(t2) < TCON_R4(c0)) {
01399    TCON_U4(t1) += 1;
01400       }
01401       c0 = t1;
01402       break;
01403     case OPC_U4F8CEIL:
01404       t1 = Targ_Conv(MTYPE_U4, c0);
01405       t2 = Targ_Conv(MTYPE_F8,t1);
01406       if (TCON_R8(t2) < TCON_R8(c0)) {
01407    TCON_U4(t1) += 1;
01408       }
01409       c0 = t1;
01410       break;
01411     case OPC_U4F10CEIL:
01412       t1 = Targ_Conv(MTYPE_U4, c0);
01413       t2 = Targ_Conv(MTYPE_F10, t1);
01414       if (TCON_R16(t2) < TCON_R16(c0)) {
01415          TCON_U4(t1) += 1;
01416       }
01417       c0 = t1;
01418       break;
01419 
01420 #ifdef TARG_NEEDS_QUAD_OPS
01421     case OPC_U4FQCEIL:
01422       t1 = Targ_Conv(MTYPE_U4, c0);
01423       t2 = Targ_Conv(MTYPE_FQ,t1);
01424       if (__c_q_lt(R16_To_RQ(TCON_R16(t2)),R16_To_RQ(TCON_R16(c0)),&err)) {
01425    TCON_U4(t1) += 1;
01426       }
01427       c0 = t1;
01428       break;
01429 #endif
01430 
01431     case OPC_U8F4CEIL:
01432       t1 = Targ_Conv(MTYPE_U8, c0);
01433       t2 = Targ_Conv(MTYPE_F4,t1);
01434       if (TCON_R4(t2) < TCON_R4(c0)) {
01435    TCON_U8(t1) += 1;
01436       }
01437       c0 = t1;
01438       break;
01439     case OPC_U8F8CEIL:
01440       t1 = Targ_Conv(MTYPE_U8, c0);
01441       t2 = Targ_Conv(MTYPE_F8,t1);
01442       if (TCON_R8(t2) < TCON_R8(c0)) {
01443    TCON_U8(t1) += 1;
01444       }
01445       c0 = t1;
01446       break;
01447     case OPC_U8F10CEIL:
01448       t1 = Targ_Conv(MTYPE_U8, c0);
01449       t2 = Targ_Conv(MTYPE_F10, t1);
01450       if (TCON_R16(t2) < TCON_R16(c0)) {
01451          TCON_U8(t1) += 1;
01452       }
01453       c0 = t1;
01454       break;
01455 
01456 #ifdef TARG_NEEDS_QUAD_OPS
01457     case OPC_U8FQCEIL:
01458       t1 = Targ_Conv(MTYPE_U8, c0);
01459       t2 = Targ_Conv(MTYPE_FQ,t1);
01460       if (__c_q_lt(R16_To_RQ(TCON_R16(t2)),R16_To_RQ(TCON_R16(c0)),&err)) {
01461    TCON_U8(t1) += 1;
01462       }
01463       c0 = t1;
01464       break;
01465 #endif
01466      
01467 #ifdef TARG_NEEDS_QUAD_OPS
01468     case OPC_FQI4CVT:
01469     case OPC_FQU4CVT:
01470     case OPC_FQI8CVT:
01471     case OPC_FQU8CVT:
01472       c0 = Targ_Conv(OPCODE_rtype(op),Targ_Conv(OPCODE_desc(op),c0));
01473       break;
01474 #endif
01475     case OPC_F4I4CVT:
01476     case OPC_F8I4CVT:
01477     case OPC_F10I4CVT:
01478     case OPC_F4U4CVT:
01479     case OPC_F8U4CVT:
01480     case OPC_F10U4CVT:
01481     case OPC_F4I8CVT:
01482     case OPC_F8I8CVT:
01483     case OPC_F10I8CVT:
01484     case OPC_F4U8CVT:
01485     case OPC_F8U8CVT:
01486     case OPC_F10U8CVT:
01487       c0 = Targ_Conv(OPCODE_rtype(op),Targ_Conv(OPCODE_desc(op),c0));
01488       break;
01489       
01490 
01491       /* The 1 and 2 byte types can safely be typecast like this,
01492    since no additional bit motion is necessary. */
01493     case OPC_I1TAS:
01494     case OPC_U1TAS:
01495     case OPC_I2TAS:
01496     case OPC_U2TAS:
01497       TCON_ty(c0) = OPCODE_rtype(op);
01498       break;
01499 
01500 
01501       /* If TAS can't be applied to complex types, these are safe
01502    since the bits are in the same position in the TCON structure */
01503     case OPC_I8TAS:
01504     case OPC_U8TAS:
01505     case OPC_F8TAS:
01506     case OPC_F10TAS:
01507     case OPC_FQTAS:
01508       TCON_ty(c0) = OPCODE_rtype(op);
01509       break;
01510 
01511 
01512     case OPC_U4TAS:
01513     case OPC_I4TAS:
01514       /* Need to move the bits if the source is an F4 */
01515       if (TCON_ty(c0) == MTYPE_F4) {
01516    TCON_v0(c0) = TCON_v1(c0);
01517    TCON_v1(c0) = 0;
01518       }
01519       TCON_ty(c0) = OPCODE_rtype(op);
01520       break;
01521 
01522     case OPC_F4TAS:
01523       /* Need to move the bits if the source is not an F4 */
01524       if (TCON_ty(c0) != MTYPE_F4) {
01525    TCON_v1(c0) = TCON_v0(c0);
01526    TCON_v0(c0) = 0;
01527       }
01528       TCON_ty(c0) = MTYPE_F4;
01529       break;
01530 
01531 
01532       /* Should these even exist? */
01533     case OPC_C4TAS:
01534       TCON_ty(c0) = MTYPE_C4;
01535       break;
01536     case OPC_C8TAS:
01537       TCON_ty(c0) = MTYPE_C8;
01538       break;
01539     case OPC_C10TAS:
01540       TCON_ty(c0) = MTYPE_C10;
01541       break;
01542     case OPC_CQTAS:
01543       TCON_ty(c0) = MTYPE_CQ;
01544       break;
01545      
01546     case OPC_I8ABS:
01547       c0 = Targ_Conv(MTYPE_I8,c0);
01548       if (TCON_I8(c0) < 0) TCON_I8(c0)  = -TCON_I8(c0);
01549       break;
01550     case OPC_I4ABS:
01551       c0 = Targ_Conv(MTYPE_I4,c0);
01552       if (TCON_I4(c0) < 0) TCON_I4(c0)  = -TCON_I4(c0);
01553       break;
01554     case OPC_F4ABS:
01555       if (TCON_R4(c0) < 0) TCON_R4(c0)  = -TCON_R4(c0);
01556       break;
01557     case OPC_F8ABS:
01558       if (TCON_R8(c0) < 0) TCON_R8(c0)  = -TCON_R8(c0);
01559       break;
01560     case OPC_F10ABS:
01561       if (TCON_R16(c0) < 0) TCON_R16(c0) = -TCON_R16(c0);
01562       break;
01563 
01564 #ifdef TARG_NEEDS_QUAD_OPS
01565     case OPC_FQABS:
01566       if (__c_q_lt(R16_To_RQ(TCON_R16(c0)),
01567        __c_q_flotj(0, &err), 
01568        &err))
01569   TCON_R16(c0) = RQ_To_R16(__c_q_neg(R16_To_RQ(TCON_R16(c0)), 
01570              &err));
01571       break;
01572 #endif
01573      
01574     case OPC_I8NEG:
01575       c0 = Targ_Conv(MTYPE_I8,c0);
01576       TCON_I8(c0)  = -TCON_I8(c0);
01577       break;
01578     case OPC_I4NEG:
01579       c0 = Targ_Conv(MTYPE_I4,c0);
01580       TCON_I4(c0)  = -TCON_I4(c0);
01581       break;
01582     case OPC_U8NEG:
01583       c0 = Targ_Conv(MTYPE_U8,c0);
01584       TCON_U8(c0)  = -TCON_U8(c0);
01585       break;
01586     case OPC_U4NEG:
01587       c0 = Targ_Conv(MTYPE_U4,c0);
01588       TCON_U4(c0)  = -TCON_U4(c0);
01589       break;
01590     case OPC_F4NEG:
01591       TCON_R4(c0)  = -TCON_R4(c0);
01592       break;
01593     case OPC_F8NEG:
01594       TCON_R8(c0)  = -TCON_R8(c0);
01595       break;
01596     case OPC_F10NEG:
01597       TCON_R16(c0)  = -TCON_R16(c0);
01598       break;
01599 
01600 #ifdef TARG_NEEDS_QUAD_OPS
01601     case OPC_FQNEG:
01602       TCON_R16(c0) = RQ_To_R16(__c_q_neg(R16_To_RQ(TCON_R16(c0)), 
01603            &err));
01604       
01605       break;
01606 #endif
01607     case OPC_C4NEG:
01608       TCON_R4(c0)  = -TCON_R4(c0);
01609       TCON_IR4(c0)  = -TCON_IR4(c0);
01610       break;
01611     case OPC_C8NEG:
01612       TCON_R8(c0)  = -TCON_R8(c0);
01613       TCON_IR8(c0)  = -TCON_IR8(c0);
01614       break;
01615 #ifdef TARG_IA64
01616     case OPC_C10NEG:
01617       TCON_R16(c0)  = -TCON_R16(c0);
01618       TCON_IR16(c0)  = -TCON_IR16(c0);
01619       break;
01620 #endif    
01621 
01622 #ifdef TARG_NEEDS_QUAD_OPS
01623     case OPC_CQNEG:
01624       TCON_R16(c0) = RQ_To_R16(__c_q_neg(R16_To_RQ(TCON_R16(c0)), 
01625            &err));
01626       TCON_IR16(c0) = RQ_To_R16(__c_q_neg(R16_To_RQ(TCON_IR16(c0)), 
01627             &err));
01628       
01629       break;
01630 #endif
01631      
01632     case OPC_BLAND:
01633     case OPC_I4LAND:
01634     case OPC_BCAND:
01635     case OPC_I4CAND:
01636       TCON_v0(c0) = TCON_U4(c0) && TCON_U4(c1); 
01637       TCON_ty(c0) = LOGICAL_MTYPE;
01638       break;
01639      
01640     case OPC_BLIOR:
01641     case OPC_I4LIOR:
01642     case OPC_BCIOR:
01643     case OPC_I4CIOR:
01644       TCON_v0(c0) = TCON_U4(c0) || TCON_U4(c1);
01645       TCON_ty(c0) = LOGICAL_MTYPE;
01646       break;
01647      
01648     case OPC_BLNOT:
01649     case OPC_I4LNOT:
01650       switch (TCON_ty(c0)) {
01651         case MTYPE_I4:
01652     TCON_v0(c0) = (TCON_I4(c0) == 0);
01653     break;
01654         case MTYPE_U4:
01655     TCON_v0(c0) = (TCON_U4(c0) == 0);
01656     break;
01657         case MTYPE_I8:
01658     TCON_v0(c0) = (TCON_I8(c0) == 0);
01659     break;
01660         case MTYPE_U8:
01661     TCON_v0(c0) = (TCON_U8(c0) == 0);
01662     break;
01663   default:
01664     FmtAssert(0,("Targ_WhirlOp, illegal operand type for LNOT"));
01665     break;
01666       }
01667       TCON_ty(c0) = OPCODE_rtype(op);
01668       break;
01669      
01670     case OPC_I8BXOR:    /* type of result is already correct */
01671       BOTH_OPNDS(c0,c1,MTYPE_I8);
01672       TCON_I8(c0) ^= TCON_I8(c1);
01673       break;
01674     case OPC_I4BXOR:
01675       BOTH_OPNDS(c0,c1,MTYPE_I4);
01676       TCON_I4(c0) ^= TCON_I4(c1);
01677       break;
01678     case OPC_U8BXOR:    /* type of result is already correct */
01679       BOTH_OPNDS(c0,c1,MTYPE_U8);
01680       TCON_U8(c0) ^= TCON_U8(c1);
01681       break;
01682     case OPC_U4BXOR:
01683       BOTH_OPNDS(c0,c1,MTYPE_U4);
01684       TCON_U4(c0) ^= TCON_U4(c1);
01685       break;
01686      
01687     case OPC_I8BAND:    /* type of result is already correct */
01688       BOTH_OPNDS(c0,c1,MTYPE_I8);
01689       TCON_I8(c0) &= TCON_I8(c1);
01690       break;
01691     case OPC_I4BAND:
01692       BOTH_OPNDS(c0,c1,MTYPE_I4);
01693       TCON_I4(c0) &= TCON_I4(c1);
01694       break;
01695     case OPC_U8BAND:    /* type of result is already correct */
01696       BOTH_OPNDS(c0,c1,MTYPE_U8);
01697       TCON_U8(c0) &= TCON_U8(c1);
01698       break;
01699     case OPC_U4BAND:
01700       BOTH_OPNDS(c0,c1,MTYPE_U4);
01701       TCON_U4(c0) &= TCON_U4(c1);
01702       break;
01703      
01704     case OPC_I8BIOR:    /* type of result is already correct */
01705       BOTH_OPNDS(c0,c1,MTYPE_I8);
01706       TCON_I8(c0) |= TCON_I8(c1);
01707       break;
01708     case OPC_I4BIOR:
01709       BOTH_OPNDS(c0,c1,MTYPE_I4);
01710       TCON_I4(c0) |= TCON_I4(c1);
01711       break;
01712     case OPC_U8BIOR:    /* type of result is already correct */
01713       BOTH_OPNDS(c0,c1,MTYPE_U8);
01714       TCON_U8(c0) |= TCON_U8(c1);
01715       break;
01716     case OPC_U4BIOR:
01717       BOTH_OPNDS(c0,c1,MTYPE_U4);
01718       TCON_U4(c0) |= TCON_U4(c1);
01719       break;
01720 
01721     case OPC_I8BNOR:    /* type of result is already correct */
01722       BOTH_OPNDS(c0,c1,MTYPE_I8);
01723       TCON_I8(c0) |= TCON_I8(c1);
01724       TCON_I8(c0) = ~TCON_I8(c0);
01725       break;
01726     case OPC_I4BNOR:
01727       BOTH_OPNDS(c0,c1,MTYPE_I4);
01728       TCON_I4(c0) |= TCON_I4(c1);
01729       TCON_I4(c0) = ~TCON_I4(c0);
01730       break;
01731     case OPC_U8BNOR:    /* type of result is already correct */
01732       BOTH_OPNDS(c0,c1,MTYPE_U8);
01733       TCON_U8(c0) |= TCON_U8(c1);
01734       TCON_U8(c0) = ~TCON_U8(c0);
01735       break;
01736     case OPC_U4BNOR:
01737       BOTH_OPNDS(c0,c1,MTYPE_U4);
01738       TCON_U4(c0) |= TCON_U4(c1);
01739       TCON_U4(c0) = ~TCON_U4(c0);
01740       break;
01741      
01742     case OPC_I8BNOT:    /* type of result is already correct */
01743       c0 = Targ_Conv(MTYPE_I8,c0);
01744       TCON_I8(c0) = ~TCON_I8(c0);
01745       break;
01746     case OPC_I4BNOT:
01747       c0 = Targ_Conv(MTYPE_I4,c0);
01748       TCON_I4(c0) = ~TCON_I4(c0);
01749       break;
01750     case OPC_U8BNOT:    /* type of result is already correct */
01751       c0 = Targ_Conv(MTYPE_U8,c0);
01752       TCON_U8(c0) = ~TCON_U8(c0);
01753       break;
01754     case OPC_U4BNOT:
01755       c0 = Targ_Conv(MTYPE_U4,c0);
01756       TCON_U4(c0) = ~TCON_U4(c0);
01757       break;
01758      
01759       
01760     case OPC_I8ADD:   /* type of result is already correct */
01761       BOTH_OPNDS(c0,c1,MTYPE_I8);
01762       TCON_I8(c0) += TCON_I8(c1);
01763       break;
01764     case OPC_I4ADD:
01765       BOTH_OPNDS(c0,c1,MTYPE_I4);
01766       TCON_I4(c0) += TCON_I4(c1);
01767       break;
01768     case OPC_U8ADD:
01769       BOTH_OPNDS(c0,c1,MTYPE_U8);
01770       TCON_U8(c0) += TCON_U8(c1);
01771       break;
01772     case OPC_U4ADD:
01773       BOTH_OPNDS(c0,c1,MTYPE_U4);
01774       TCON_U4(c0) += TCON_U4(c1);
01775       break;
01776     case OPC_F4ADD:
01777       TCON_R4(c0) += TCON_R4(c1);
01778       break;
01779     case OPC_F8ADD:
01780       TCON_R8(c0) += TCON_R8(c1);
01781       break;
01782     case OPC_F10ADD:
01783       TCON_R16(c0) += TCON_R16(c1);
01784       break;
01785 
01786 #ifdef TARG_NEEDS_QUAD_OPS
01787     case OPC_FQADD:
01788       
01789       
01790       TCON_R16(c0) = RQ_To_R16(__c_q_add(R16_To_RQ(TCON_R16(c0)), 
01791            R16_To_RQ(TCON_R16(c1)), 
01792            &err));
01793       
01794       break;
01795 #endif
01796     case OPC_C4ADD:
01797       TCON_R4(c0) += TCON_R4(c1);
01798       TCON_IR4(c0) += TCON_IR4(c1);
01799       break;
01800     case OPC_C8ADD:
01801       TCON_R8(c0) += TCON_R8(c1);
01802       TCON_IR8(c0) += TCON_IR8(c1);
01803       break;
01804 #ifdef TARG_IA64
01805     case OPC_C10ADD:
01806       TCON_R16(c0) += TCON_R16(c1);
01807       TCON_IR16(c0) += TCON_IR16(c1);
01808       break;
01809 #endif      
01810 
01811 #ifdef TARG_NEEDS_QUAD_OPS
01812     case OPC_CQADD:
01813       TCON_R16(c0) = RQ_To_R16(__c_q_add(R16_To_RQ(TCON_R16(c0)), 
01814            R16_To_RQ(TCON_R16(c1)), 
01815            &err));
01816       TCON_IR16(c0) = RQ_To_R16(__c_q_add(R16_To_RQ(TCON_IR16(c0)), 
01817             R16_To_RQ(TCON_IR16(c1)), 
01818             &err));
01819       
01820       break;
01821 #endif
01822 
01823     case OPC_I8SUB:   /* type of result is already correct */
01824       BOTH_OPNDS(c0,c1,MTYPE_I8);
01825       TCON_I8(c0) -= TCON_I8(c1);
01826       break;
01827     case OPC_I4SUB:
01828       BOTH_OPNDS(c0,c1,MTYPE_I4);
01829       TCON_I4(c0) -= TCON_I4(c1);
01830       break;
01831     case OPC_U8SUB:
01832       BOTH_OPNDS(c0,c1,MTYPE_U8);
01833       TCON_U8(c0) -= TCON_U8(c1);
01834       break;
01835     case OPC_U4SUB:
01836       BOTH_OPNDS(c0,c1,MTYPE_U4);
01837       TCON_U4(c0) -= TCON_U4(c1);
01838       break;
01839     case OPC_F4SUB:
01840       TCON_R4(c0) -= TCON_R4(c1);
01841       break;
01842     case OPC_F8SUB:
01843       TCON_R8(c0) -= TCON_R8(c1);
01844       break;
01845     case OPC_F10SUB:
01846       TCON_R16(c0) -= TCON_R16(c1);
01847       break;
01848 
01849 #ifdef TARG_NEEDS_QUAD_OPS
01850     case OPC_FQSUB:
01851       
01852       
01853       TCON_R16(c0) = RQ_To_R16(__c_q_sub(R16_To_RQ(TCON_R16(c0)), 
01854            R16_To_RQ(TCON_R16(c1)), 
01855            &err));
01856       
01857       break;
01858 #endif
01859     case OPC_C4SUB:
01860       TCON_R4(c0) -= TCON_R4(c1);
01861       TCON_IR4(c0) -= TCON_IR4(c1);
01862       break;
01863     case OPC_C8SUB:
01864       TCON_R8(c0) -= TCON_R8(c1);
01865       TCON_IR8(c0) -= TCON_IR8(c1);
01866       break;
01867 #ifdef TARG_IA64
01868     case OPC_C10SUB:
01869       TCON_R16(c0) -= TCON_R16(c1);
01870       TCON_IR16(c0) -= TCON_IR16(c1);
01871       break;
01872 #endif      
01873 #ifdef TARG_NEEDS_QUAD_OPS
01874     case OPC_CQSUB:
01875       
01876       
01877       TCON_R16(c0) = RQ_To_R16(__c_q_sub(R16_To_RQ(TCON_R16(c0)), 
01878            R16_To_RQ(TCON_R16(c1)), 
01879            &err));
01880       TCON_IR16(c0) = RQ_To_R16(__c_q_sub(R16_To_RQ(TCON_IR16(c0)), 
01881             R16_To_RQ(TCON_IR16(c1)), 
01882             &err));
01883       
01884       break;
01885 #endif
01886 
01887     case OPC_F8SQRT:
01888       if (TCON_R8(c0) >= 0) {
01889   TCON_R8(c0) = sqrt(TCON_R8(c0));
01890       } else {
01891   *folded = FALSE;
01892       }
01893       break;
01894     case OPC_F4SQRT:
01895       if (TCON_R4(c0) >= 0) {
01896   TCON_R4(c0) = sqrtf(TCON_R4(c0));
01897       } else {
01898   *folded = FALSE;
01899       }
01900       break;
01901     case OPC_F10SQRT:
01902       if (TCON_R16(c0) >= 0) {
01903         TCON_R16(c0) = sqrtl(TCON_R16(c0));
01904       } else {
01905         *folded = FALSE;
01906       }
01907       break;
01908 
01909 #ifdef TARG_NEEDS_QUAD_OPS
01910     case OPC_FQSQRT:
01911       if (__c_q_ge(R16_To_RQ(TCON_R16(c0)), 
01912        __c_q_flotj(0, &err), 
01913        &err)) {
01914   TCON_R16(c0) = RQ_To_R16(__c_q_sqrt(R16_To_RQ(TCON_R16(c0)), 
01915               &err));
01916       } else {
01917   *folded = FALSE;
01918       }
01919       break;
01920 #endif
01921     case OPC_C4SQRT:
01922     case OPC_C8SQRT:
01923 #ifdef TARG_IA64
01924     case OPC_C10SQRT:
01925 #endif      
01926     case OPC_CQSQRT:
01927       c0 = complex_sqrt(c0);
01928       break;
01929 
01930     case OPC_I8MPY:   /* type of result is already correct */
01931       BOTH_OPNDS(c0,c1,MTYPE_I8);
01932       TCON_I8(c0) *= TCON_I8(c1);
01933       break;
01934     case OPC_I4MPY:
01935       BOTH_OPNDS(c0,c1,MTYPE_I4);
01936       TCON_I4(c0) *= TCON_I4(c1);
01937       break;
01938     case OPC_U8MPY:
01939       BOTH_OPNDS(c0,c1,MTYPE_U8);
01940       TCON_U8(c0) *= TCON_U8(c1);
01941       break;
01942     case OPC_U4MPY:
01943       BOTH_OPNDS(c0,c1,MTYPE_U4);
01944       TCON_U4(c0) *= TCON_U4(c1);
01945       break;
01946     case OPC_F4MPY:
01947       TCON_R4(c0) *= TCON_R4(c1);
01948       break;
01949     case OPC_F8MPY:
01950       TCON_R8(c0) *= TCON_R8(c1);
01951       break;
01952     case OPC_F10MPY:
01953       TCON_R16(c0) *= TCON_R16(c1);
01954       break;
01955 
01956 #ifdef TARG_NEEDS_QUAD_OPS
01957     case OPC_FQMPY:
01958       
01959       
01960       TCON_R16(c0) = RQ_To_R16(__c_q_mul(R16_To_RQ(TCON_R16(c0)), 
01961            R16_To_RQ(TCON_R16(c1)), 
01962            &err));
01963       
01964       break;
01965 #endif
01966 
01967     case OPC_C4MPY:
01968       TCON_R4(t1) = TCON_R4(c0)*TCON_R4(c1) - TCON_IR4(c0)*TCON_IR4(c1);
01969       TCON_IR4(c0) = TCON_R4(c0)*TCON_IR4(c1) + TCON_IR4(c0)*TCON_R4(c1);
01970       TCON_R4(c0) = TCON_R4(t1);
01971       break;
01972     case OPC_C8MPY:
01973       TCON_R8(t1) = TCON_R8(c0)*TCON_R8(c1) - TCON_IR8(c0)*TCON_IR8(c1);
01974       TCON_IR8(c0) = TCON_R8(c0)*TCON_IR8(c1) + TCON_IR8(c0)*TCON_R8(c1);
01975       TCON_R8(c0) = TCON_R8(t1);
01976       break;
01977 
01978 #ifdef TARG_IA64
01979     case OPC_C10MPY:
01980       TCON_R16(t1) = TCON_R16(c0)*TCON_R16(c1) - TCON_IR16(c0)*TCON_IR16(c1);
01981       TCON_IR16(c0) = TCON_R16(c0)*TCON_IR16(c1) + TCON_IR16(c0)*TCON_R16(c1);
01982       TCON_R16(c0) = TCON_R16(t1);
01983       break;
01984 #endif      
01985       
01986 #ifdef TARG_NEEDS_QUAD_OPS
01987     case OPC_CQMPY:
01988       {
01989    QUAD a,b,c,d,r1,r2,r3;
01990    a = R16_To_RQ(TCON_R16(c0));
01991    b = R16_To_RQ(TCON_IR16(c0));
01992    c = R16_To_RQ(TCON_R16(c1));
01993    d = R16_To_RQ(TCON_IR16(c1));
01994    r1 = __c_q_mul(a,c,&err);
01995    r2 = __c_q_mul(b,d,&err);
01996    r3 = __c_q_sub(r1,r2,&err);
01997    r1 = __c_q_mul(a,d,&err);
01998    r2 = __c_q_mul(b,c,&err);
01999    r1 = __c_q_add(r1,r2,&err);
02000    TCON_R16(c0) = RQ_To_R16(r3);  
02001    TCON_IR16(c0) = RQ_To_R16(r1);  
02002       }
02003       break;
02004 #endif
02005 
02006     case OPC_I8DIV:   /* type of result is already correct */
02007       BOTH_OPNDS(c0,c1,MTYPE_I8);
02008       if (TCON_I8(c1) != 0) {
02009    /* check for possible integer overflow */
02010    if ( TCON_I8(c1) != -1 || TCON_I8(c0) != MIN_INT_I8 )
02011      TCON_I8(c0) /= TCON_I8(c1); 
02012    else {
02013 /*      ErrMsg( EC_Ill_Divide );*/
02014             *folded = FALSE;
02015       /* leave c0 as MIN_INT_I8 */
02016    }
02017       }
02018       else {
02019    /* divide by zero; so don't fold */
02020 /*          ErrMsg( EC_Ill_Int_Oflow, TCON_I8(c0), "/", TCON_I8(c1) );*/
02021    *folded = FALSE;
02022       }
02023       break;
02024     case OPC_I4DIV:
02025       BOTH_OPNDS(c0,c1,MTYPE_I4);
02026       if (TCON_I4(c1) != 0) {
02027    /* check for possible integer overflow */
02028    if ( TCON_I4(c1) != -1 || TCON_I4(c0) != MIN_INT_I4 )
02029      TCON_I4(c0) /= TCON_I4(c1);
02030    else {
02031      *folded = FALSE;
02032 /*     ErrMsg( EC_Ill_Int_Oflow, TCON_I4(c0), "/", TCON_I4(c1) );*/
02033   }
02034       }
02035       else {
02036    /* divide by zero; so don't fold */
02037 /*   ErrMsg( EC_Ill_Divide );*/
02038    *folded = FALSE;
02039       }
02040       break;
02041     case OPC_U8DIV:
02042       BOTH_OPNDS(c0,c1,MTYPE_U8);
02043       if (TCON_U8(c1) != 0)
02044   TCON_U8(c0) /= TCON_U8(c1);
02045       else {
02046    /* divide by zero; so don't fold */
02047 /*   ErrMsg( EC_Ill_UDivide );*/
02048    *folded = FALSE;
02049       }
02050       break;
02051     case OPC_U4DIV:
02052       BOTH_OPNDS(c0,c1,MTYPE_U4);
02053       if (TCON_U4(c1) != 0)
02054   TCON_U4(c0) /= TCON_U4(c1);
02055       else {
02056    /* divide by zero; so don't fold */
02057 /*   ErrMsg( EC_Ill_UDivide );*/
02058    *folded = FALSE;
02059       }
02060       break;
02061     case OPC_F4DIV:
02062       if (TCON_R4(c1) == 0.0) {
02063    /* divide by zero; so don't fold */
02064    *folded = FALSE;
02065       }
02066       TCON_R4(c0) /= TCON_R4(c1);
02067       break;
02068     case OPC_F8DIV:
02069       if (TCON_R8(c1) == 0.0) {
02070    /* divide by zero; so don't fold */
02071    *folded = FALSE;
02072       }
02073       TCON_R8(c0) /= TCON_R8(c1);
02074       break;
02075     case OPC_F10DIV:
02076       if (TCON_R16(c1) == 0.0) {
02077          /* divide by zero; so don't fold */
02078          *folded = FALSE;
02079       }
02080       TCON_R16(c0) /= TCON_R16(c1);
02081       break;
02082 
02083 #ifdef TARG_NEEDS_QUAD_OPS
02084     case OPC_FQDIV:
02085       
02086       
02087       if (__c_q_eq(R16_To_RQ(TCON_R16(c1)), 
02088        __c_q_flotj(0, &err), 
02089        &err)) {
02090    /* divide by zero; so don't fold */
02091 /*   ErrMsg( EC_Ill_Divide );*/
02092    *folded = FALSE;
02093    /* break; */
02094       }
02095       TCON_R16(c0) = RQ_To_R16(__c_q_div(R16_To_RQ(TCON_R16(c0)), 
02096            R16_To_RQ(TCON_R16(c1)), 
02097            &err));
02098       
02099       break;
02100 #endif
02101 
02102     case OPC_C8DIV:
02103 #ifdef TARG_IA64
02104     case OPC_C10DIV:
02105 #endif      
02106     case OPC_CQDIV:
02107     case OPC_C4DIV:
02108       c0 = complex_divide(c0,c1);
02109       break;
02110       
02111     case OPC_I8REM:   /* type of result is already correct */
02112       BOTH_OPNDS(c0,c1,MTYPE_I8);
02113       if (TCON_I8(c1) != 0) {
02114    /* check for possible integer overflow */
02115    if ( TCON_I8(c1) != -1 || TCON_I8(c0) != MIN_INT_I8 )
02116      TCON_I8(c0) %= TCON_I8(c1);
02117    else {
02118 /*     ErrMsg( EC_Ill_Int_Oflow, TCON_I8(c0), "%", TCON_I8(c1) );*/
02119      *folded = FALSE;
02120   }
02121       }
02122       else {
02123   /* rem by zero; so don't fold */
02124 /*   ErrMsg( EC_Ill_Modulus );*/
02125   *folded = FALSE;
02126       }
02127       break;
02128     case OPC_I4REM:
02129       BOTH_OPNDS(c0,c1,MTYPE_I4);
02130       if (TCON_I4(c1) != 0) {
02131    /* check for possible integer overflow */
02132    if ( TCON_I4(c1) != -1 || TCON_I4(c0) != MIN_INT_I4 )
02133      TCON_I4(c0) %= TCON_I4(c1);
02134    else {
02135 /*     ErrMsg( EC_Ill_Int_Oflow, TCON_I4(c0), "%", TCON_I4(c1) );*/
02136      *folded = FALSE;
02137   }
02138       }
02139       else {
02140   /* rem by zero; so don't fold */
02141 /*   ErrMsg( EC_Ill_Modulus );*/
02142   *folded = FALSE;
02143       }
02144       break;
02145     case OPC_U8REM:
02146       BOTH_OPNDS(c0,c1,MTYPE_U8);
02147       if (TCON_U8(c1) != 0)
02148   TCON_U8(c0) %= TCON_U8(c1); 
02149       else {
02150   /* rem by zero; so don't fold */
02151 /*   ErrMsg( EC_Ill_UModulus );*/
02152   *folded = FALSE;
02153       }
02154       break;
02155     case OPC_U4REM:
02156       BOTH_OPNDS(c0,c1,MTYPE_U4);
02157       if (TCON_U4(c1) != 0)
02158   TCON_U4(c0) %= TCON_U4(c1);
02159       else {
02160   /* rem by zero; so don't fold */
02161 /*   ErrMsg( EC_Ill_UModulus );*/
02162   *folded = FALSE;
02163       }
02164       break;
02165 
02166     case OPC_I8MOD:   /* type of result is already correct */
02167       BOTH_OPNDS(c0,c1,MTYPE_I8);
02168       if (TCON_I8(c1) != 0) {
02169    /* check for possible integer overflow */
02170    if ( TCON_I8(c1) != -1 || TCON_I8(c0) != MIN_INT_I8 ) {
02171       INT64 rem = TCON_I8(c0) % TCON_I8(c1);
02172       if ( rem != 0 && ( (TCON_I8(c0)>0) ^ (TCON_I8(c1)>0) ) ) 
02173         rem += TCON_I8(c1);
02174       TCON_I8(c0) = rem;
02175    }
02176    else {
02177 /*     ErrMsg( EC_Ill_Int_Oflow, TCON_I8(c0), "%", TCON_I8(c1) );*/
02178      *folded = FALSE;
02179   }
02180       } else {
02181   /* mod by 0; so don't fold */
02182 /*   ErrMsg( EC_Ill_Modulus );*/
02183   *folded = FALSE;
02184       }
02185       break;
02186     case OPC_I4MOD:
02187       BOTH_OPNDS(c0,c1,MTYPE_I4);
02188       if (TCON_I4(c1) != 0) {
02189    /* check for possible integer overflow */
02190    if ( TCON_I4(c1) != -1 || TCON_I4(c0) != MIN_INT_I4 ) {
02191       INT32 rem = TCON_I4(c0) % TCON_I4(c1);
02192       if ( rem != 0 && ( (TCON_I4(c0)>0) ^ (TCON_I4(c1)>0) ) ) 
02193         rem += TCON_I4(c1);
02194       TCON_I4(c0) = rem;
02195    }
02196    else {
02197 /*     ErrMsg( EC_Ill_Int_Oflow, TCON_I4(c0), "%", TCON_I4(c1) );*/
02198      *folded = FALSE;
02199   }
02200       } else {
02201   /* mod by 0; so don't fold */
02202 /*   ErrMsg( EC_Ill_Modulus );*/
02203   *folded = FALSE;
02204       }
02205       break;
02206     case OPC_U8MOD:
02207       BOTH_OPNDS(c0,c1,MTYPE_U8);
02208       if (TCON_U8(c1) != 0)
02209   TCON_U8(c0) %= TCON_U8(c1); 
02210       else {
02211   /* mod by 0; so don't fold */
02212 /*   ErrMsg( EC_Ill_UModulus );*/
02213   *folded = FALSE;
02214       }
02215       break;
02216     case OPC_U4MOD:
02217       BOTH_OPNDS(c0,c1,MTYPE_U4);
02218       if (TCON_U4(c1) != 0)
02219   TCON_U4(c0) %= TCON_U4(c1);
02220       else {
02221   /* mod by 0; so don't fold */
02222 /*   ErrMsg( EC_Ill_UModulus );*/
02223   *folded = FALSE;
02224       }
02225       break;
02226 
02227 
02228     case OPC_F4RECIP:
02229       c0 = Targ_WhirlOp(OPC_F4DIV,Host_To_Targ_Float(MTYPE_F4,1.0),c0,folded);
02230       break;
02231     case OPC_F8RECIP:
02232       c0 = Targ_WhirlOp(OPC_F8DIV,Host_To_Targ_Float(MTYPE_F8,1.0),c0,folded);
02233       break;
02234     case OPC_F10RECIP:
02235       c0 = Targ_WhirlOp(OPC_F10DIV,Host_To_Targ_Float(MTYPE_F10,1.0),c0,folded);
02236       break;
02237     case OPC_FQRECIP:
02238       c0 = Targ_WhirlOp(OPC_FQDIV,Host_To_Targ_Float(MTYPE_FQ,1.0),c0,folded);
02239       break;
02240     case OPC_C4RECIP:
02241       c0 = Targ_WhirlOp(OPC_C4DIV,Host_To_Targ_Float(MTYPE_C4,1.0),c0,folded);
02242       break;
02243     case OPC_C8RECIP:
02244       c0 = Targ_WhirlOp(OPC_C8DIV,Host_To_Targ_Float(MTYPE_C8,1.0),c0,folded);
02245       break;
02246     case OPC_C10RECIP:
02247       c0 = Targ_WhirlOp(OPC_C10DIV,Host_To_Targ_Float(MTYPE_C10,1.0),c0,folded);
02248       break;
02249     case OPC_CQRECIP:
02250       c0 = Targ_WhirlOp(OPC_CQDIV,Host_To_Targ_Float(MTYPE_CQ,1.0),c0,folded);
02251       break;
02252 
02253     case OPC_F4RSQRT:
02254       c0 = Targ_WhirlOp(OPC_F4SQRT,c0,c0,folded);
02255       if (*folded) c0 = Targ_WhirlOp(OPC_F4DIV,Host_To_Targ_Float(MTYPE_F4,1.0),c0,folded);
02256       break;
02257     case OPC_F8RSQRT:
02258       c0 = Targ_WhirlOp(OPC_F8SQRT,c0,c0,folded);
02259       if (*folded) c0 = Targ_WhirlOp(OPC_F8DIV,Host_To_Targ_Float(MTYPE_F8,1.0),c0,folded);
02260       break;
02261     case OPC_F10RSQRT:
02262       c0 = Targ_WhirlOp(OPC_F10SQRT,c0,c0,folded);
02263       if (*folded) c0 = Targ_WhirlOp(OPC_F10DIV,Host_To_Targ_Float(MTYPE_F10,1.0),c0,folded);
02264       break;
02265     case OPC_FQRSQRT:
02266       c0 = Targ_WhirlOp(OPC_FQSQRT,c0,c0,folded);
02267       if (*folded) c0 = Targ_WhirlOp(OPC_FQDIV,Host_To_Targ_Float(MTYPE_FQ,1.0),c0,folded);
02268       break;
02269     case OPC_C4RSQRT:
02270       c0 = Targ_WhirlOp(OPC_C4SQRT,c0,c0,folded);
02271       if (*folded) c0 = Targ_WhirlOp(OPC_C4DIV,Host_To_Targ_Float(MTYPE_C4,1.0),c0,folded);
02272       break;
02273     case OPC_C8RSQRT:
02274       c0 = Targ_WhirlOp(OPC_C8SQRT,c0,c0,folded);
02275       if (*folded) c0 = Targ_WhirlOp(OPC_C8DIV,Host_To_Targ_Float(MTYPE_C8,1.0),c0,folded);
02276       break;
02277     case OPC_C10RSQRT:
02278       c0 = Targ_WhirlOp(OPC_C10SQRT,c0,c0,folded);
02279       if (*folded)
02280   c0 = Targ_WhirlOp(OPC_C10DIV, Host_To_Targ_Float(MTYPE_C10, 1.0),
02281     c0, folded);
02282       break;
02283     case OPC_CQRSQRT:
02284       c0 = Targ_WhirlOp(OPC_CQSQRT,c0,c0,folded);
02285       if (*folded) c0 = Targ_WhirlOp(OPC_CQDIV,Host_To_Targ_Float(MTYPE_CQ,1.0),c0,folded);
02286       break;
02287 
02288     case OPC_I8MIN:
02289       BOTH_OPNDS(c0,c1,MTYPE_I8);
02290       TCON_I8(c0) = TCON_I8(c0)<=TCON_I8(c1)? TCON_I8(c0) : TCON_I8(c1);
02291       break;
02292     case OPC_I4MIN:
02293       BOTH_OPNDS(c0,c1,MTYPE_I4);
02294       TCON_I4(c0) = TCON_I4(c0)<=TCON_I4(c1)? TCON_I4(c0) : TCON_I4(c1);
02295       break;
02296     case OPC_U8MIN:
02297       BOTH_OPNDS(c0,c1,MTYPE_U8);
02298       TCON_U8(c0) = TCON_U8(c0)<=TCON_U8(c1)? TCON_U8(c0) : TCON_U8(c1);
02299       break;
02300     case OPC_U4MIN:
02301       BOTH_OPNDS(c0,c1,MTYPE_U4);
02302       TCON_U4(c0) = TCON_U4(c0)<=TCON_U4(c1)? TCON_U4(c0) : TCON_U4(c1);
02303       break;
02304 
02305     case OPC_I8MAX:
02306       BOTH_OPNDS(c0,c1,MTYPE_I8);
02307       TCON_I8(c0) = TCON_I8(c0)>=TCON_I8(c1)? TCON_I8(c0) : TCON_I8(c1);
02308       break;
02309     case OPC_I4MAX:
02310       BOTH_OPNDS(c0,c1,MTYPE_I4);
02311       TCON_I4(c0) = TCON_I4(c0)>=TCON_I4(c1)? TCON_I4(c0) : TCON_I4(c1);
02312       break;
02313     case OPC_U8MAX:
02314       BOTH_OPNDS(c0,c1,MTYPE_U8);
02315       TCON_U8(c0) = TCON_U8(c0)>=TCON_U8(c1)? TCON_U8(c0) : TCON_U8(c1);
02316       break;
02317     case OPC_U4MAX:
02318       BOTH_OPNDS(c0,c1,MTYPE_U4);
02319       TCON_U4(c0) = TCON_U4(c0)>=TCON_U4(c1)? TCON_U4(c0) : TCON_U4(c1);
02320       break;
02321 
02322     case OPC_F4MIN:
02323       TCON_R4(c0) = TCON_R4(c0) < TCON_R4(c1) ? 
02324   TCON_R4(c0) : TCON_R4(c1);
02325       break;
02326     case OPC_F4MAX:
02327       TCON_R4(c0) = TCON_R4(c0) < TCON_R4(c1) ? 
02328   TCON_R4(c1) : TCON_R4(c0);
02329       break;
02330     case OPC_F8MIN:
02331       TCON_R8(c0) = TCON_R8(c0) < TCON_R8(c1) ? 
02332   TCON_R8(c0) : TCON_R8(c1);
02333       break;
02334     case OPC_F8MAX:
02335       TCON_R8(c0) = TCON_R8(c0) < TCON_R8(c1) ? 
02336   TCON_R8(c1) : TCON_R8(c0);
02337       break;
02338     case OPC_F10MIN:
02339       TCON_R16(c0) = TCON_R16(c0) < TCON_R16(c1) ?
02340         TCON_R16(c0) : TCON_R16(c1);
02341       break;
02342     case OPC_F10MAX:
02343       TCON_R16(c0) = TCON_R16(c0) < TCON_R16(c1) ?
02344         TCON_R16(c1) : TCON_R16(c0);
02345       break;
02346 
02347 #ifdef TARG_NEEDS_QUAD_OPS
02348     case OPC_FQMIN:
02349       
02350       
02351       TCON_R16(c0) = __c_q_lt(R16_To_RQ(TCON_R16(c0)), 
02352             R16_To_RQ(TCON_R16(c1)), &err) ?
02353         TCON_R16(c0) : TCON_R16(c1);
02354       
02355       break;
02356 
02357     case OPC_FQMAX:
02358       
02359       
02360       TCON_R16(c0) = __c_q_lt(R16_To_RQ(TCON_R16(c0)), 
02361             R16_To_RQ(TCON_R16(c1)), &err) ?
02362         TCON_R16(c1) : TCON_R16(c0);
02363       
02364       break;
02365 #endif
02366 
02367 
02368     case OPC_C4COMPLEX:
02369       TCON_IR4(c0) = TCON_R4(c1);
02370       TCON_ty(c0) = MTYPE_C4;
02371       break;
02372     case OPC_C8COMPLEX:
02373       TCON_IR8(c0) = TCON_R8(c1);
02374       TCON_ty(c0) = MTYPE_C8;
02375       break;
02376     case OPC_C10COMPLEX:
02377       TCON_IR16(c0) = TCON_R16(c1);
02378       TCON_ty(c0) = MTYPE_C10;
02379       break;
02380     case OPC_CQCOMPLEX:
02381       TCON_IR16(c0) = TCON_R16(c1);
02382       TCON_ty(c0) = MTYPE_CQ;
02383       break;
02384 
02385 
02386     case OPC_F4REALPART:
02387       TCON_ty(c0) = MTYPE_F4;
02388       break;
02389     case OPC_F8REALPART:
02390       TCON_ty(c0) = MTYPE_F8;
02391       break;
02392     case OPC_F10REALPART:
02393       TCON_ty(c0) = MTYPE_F10;
02394       break;
02395     case OPC_FQREALPART:
02396       TCON_ty(c0) = MTYPE_FQ;
02397       break;
02398 
02399 
02400     case OPC_F4IMAGPART:
02401       TCON_R4(c0) = TCON_IR4(c0);
02402       TCON_ty(c0) = MTYPE_F4;
02403       break;
02404     case OPC_F8IMAGPART:
02405       TCON_R8(c0) = TCON_IR8(c0);
02406       TCON_ty(c0) = MTYPE_F8;
02407       break;
02408     case OPC_F10IMAGPART:
02409       TCON_R16(c0) = TCON_IR16(c0);
02410       TCON_ty(c0) = MTYPE_F10;
02411       break;
02412     case OPC_FQIMAGPART:
02413       TCON_R16(c0) = TCON_IR16(c0);
02414       TCON_ty(c0) = MTYPE_FQ;
02415       break;
02416 
02417     default:
02418       FmtAssert ( folded, ("Targ_WhirlOp can not handle %s", OPCODE_name(op)) );
02419       *folded = FALSE;
02420       break;      
02421    }
02422 #ifdef DEBUG_FOLD
02423    printf(" 0x%llx (%s)\n",TCON_I8(c0),Mtype_Name(TCON_ty(c0)));
02424 #endif
02425 
02426    return c0;
02427 } /* Targ_WhirlOp */
02428 
02429 /* ====================================================================
02430  *
02431  * Targ_Conv
02432  *
02433  * Convert a TCON's value to a new type.  We currently assume C's
02434  * conversion rules.
02435  *
02436  * ====================================================================
02437  */
02438 
02439 TCON
02440 Targ_Conv ( TYPE_ID ty_to, TCON c )
02441 {
02442   TYPE_ID ty_from;
02443   TCON r;
02444 #ifdef TARG_NEEDS_QUAD_OPS
02445   INT32 err;
02446 #endif
02447 
02448 #define FROM_TO(type_from, type_to) (type_from)*(MTYPE_LAST+1)+(type_to)
02449 
02450   r = MTYPE_size_min(ty_to) <= 32 ? Zero_I4_Tcon : Zero_I8_Tcon;
02451   TCON_v0(r) = 0;
02452   TCON_v1(r) = 0;
02453   TCON_v2(r) = 0;
02454   TCON_v3(r) = 0;
02455   TCON_iv0(r) = 0;
02456   TCON_iv1(r) = 0;
02457   TCON_iv2(r) = 0;
02458   TCON_iv3(r) = 0;
02459   ty_from = TCON_ty(c);
02460   Is_True ( ty_to > MTYPE_UNKNOWN && ty_to <= MTYPE_LAST, 
02461       ("Bad dest type in Targ_Conv: %s", Mtype_Name(ty_to)) );
02462   Is_True ( ty_from > MTYPE_UNKNOWN && ty_from <= MTYPE_LAST, 
02463       ("Bad dest type in Targ_Conv: %s", Mtype_Name(ty_from)) );
02464 
02465   if (ty_from == ty_to) 
02466     return c;
02467   /* TODO: sign or zero extend when converting from small to large.
02468      make sure it matches convert.c
02469   */
02470   switch ( FROM_TO(ty_from, ty_to) ) {
02471 #ifdef TARG_NEEDS_QUAD_OPS
02472     case FROM_TO(MTYPE_C8, MTYPE_CQ):
02473       TCON_R16(r) = RQ_To_R16(__c_q_extd(TCON_R8(c), &err));
02474       TCON_IR16(r) = RQ_To_R16(__c_q_extd(TCON_IR8(c), &err));
02475       break;
02476     case FROM_TO(MTYPE_C4, MTYPE_CQ):
02477       TCON_R16(r) = RQ_To_R16(__c_q_ext(TCON_R4(c), &err));
02478       TCON_IR16(r) = RQ_To_R16(__c_q_ext(TCON_IR4(c), &err));
02479       break;
02480     case FROM_TO(MTYPE_FQ, MTYPE_CQ):
02481       TCON_R16(r) = TCON_R16(c);
02482       TCON_IR16(r) = RQ_To_R16(__c_q_ext(0.0, &err));
02483       break;
02484     case FROM_TO(MTYPE_F8, MTYPE_CQ):
02485       TCON_R16(r) = RQ_To_R16(__c_q_extd(TCON_R8(c), &err));
02486       TCON_IR16(r) = RQ_To_R16(__c_q_ext(0.0, &err));
02487       break;
02488     case FROM_TO(MTYPE_F4, MTYPE_CQ):
02489       TCON_R16(r) = RQ_To_R16(__c_q_ext(TCON_R4(c), &err));
02490       TCON_IR16(r) = RQ_To_R16(__c_q_ext(0.0, &err));
02491       break;
02492     case FROM_TO(MTYPE_I8, MTYPE_CQ): 
02493       TCON_R16(r) = RQ_To_R16(__c_q_flotk(TCON_I8(c), &err));
02494       TCON_IR16(r) = RQ_To_R16(__c_q_ext(0.0, &err));
02495       break;
02496     case FROM_TO(MTYPE_I4, MTYPE_CQ): 
02497     case FROM_TO(MTYPE_I2, MTYPE_CQ): 
02498     case FROM_TO(MTYPE_I1, MTYPE_CQ): 
02499       TCON_R16(r) = RQ_To_R16(__c_q_flotj(TCON_v0(c), &err));
02500       TCON_IR16(r) = RQ_To_R16(__c_q_ext(0.0, &err));
02501       break;
02502     case FROM_TO(MTYPE_U8, MTYPE_CQ):
02503       TCON_R16(r) = RQ_To_R16(__c_q_flotku(TCON_U8(c), &err));
02504       TCON_IR16(r) = RQ_To_R16(__c_q_ext(0.0, &err));
02505       break;
02506     case FROM_TO(MTYPE_U4, MTYPE_CQ):
02507     case FROM_TO(MTYPE_U2, MTYPE_CQ):
02508     case FROM_TO(MTYPE_U1, MTYPE_CQ):
02509       TCON_R16(r) = RQ_To_R16(__c_q_flotju(TCON_u0(c), &err));
02510       TCON_IR16(r) = RQ_To_R16(__c_q_ext(0.0, &err));
02511       break;
02512     case FROM_TO(MTYPE_CQ, MTYPE_C8):
02513       TCON_R8(r) = __c_dble_q(R16_To_RQ(TCON_R16(c)), &err);
02514       TCON_IR8(r) = __c_dble_q(R16_To_RQ(TCON_IR16(c)), &err);
02515       break;
02516     case FROM_TO(MTYPE_CQ, MTYPE_C4):
02517       Set_TCON_R4(r, __c_sngl_q(R16_To_RQ(TCON_R16(c)), &err));
02518       Set_TCON_IR4(r, __c_sngl_q(R16_To_RQ(TCON_IR16(c)), &err));
02519       break;
02520     case FROM_TO(MTYPE_CQ, MTYPE_FQ):
02521       TCON_R16(r) = TCON_R16(c);
02522       break;
02523     case FROM_TO(MTYPE_CQ, MTYPE_F8):
02524       TCON_R8(r) = __c_dble_q(R16_To_RQ(TCON_R16(c)), &err);
02525       break;
02526     case FROM_TO(MTYPE_CQ, MTYPE_F4):
02527       Set_TCON_R4(r, __c_sngl_q(R16_To_RQ(TCON_R16(c)), &err));
02528       break;
02529     case FROM_TO(MTYPE_CQ, MTYPE_I8):
02530       TCON_I8(r) = __c_ki_qint(R16_To_RQ(TCON_R16(c)), &err);
02531       break;
02532     case FROM_TO(MTYPE_CQ, MTYPE_I4):
02533     case FROM_TO(MTYPE_CQ, MTYPE_I2):
02534     case FROM_TO(MTYPE_CQ, MTYPE_I1):
02535       TCON_v0(r) = __c_ji_qint(R16_To_RQ(TCON_R16(c)), &err);
02536       break;
02537     case FROM_TO(MTYPE_CQ, MTYPE_U8):
02538       TCON_U8(r) = __c_ki_quint(R16_To_RQ(TCON_R16(c)), &err);
02539       break;
02540     case FROM_TO(MTYPE_CQ, MTYPE_U4):
02541     case FROM_TO(MTYPE_CQ, MTYPE_U2):
02542     case FROM_TO(MTYPE_CQ, MTYPE_U1):
02543       TCON_u0(r) = __c_ji_quint(R16_To_RQ(TCON_R16(c)), &err);
02544       break;
02545 
02546     case FROM_TO(MTYPE_C8, MTYPE_FQ):
02547       TCON_R16(r) = RQ_To_R16(__c_q_extd(TCON_R8(c), &err));
02548       break;
02549     case FROM_TO(MTYPE_C4, MTYPE_FQ):
02550       TCON_R16(r) = RQ_To_R16(__c_q_ext(TCON_R4(c), &err));
02551       break;
02552     case FROM_TO(MTYPE_F8, MTYPE_FQ):
02553       TCON_R16(r) = RQ_To_R16(__c_q_extd(TCON_R8(c), &err));
02554       break;
02555     case FROM_TO(MTYPE_F4, MTYPE_FQ):
02556       TCON_R16(r) = RQ_To_R16(__c_q_ext(TCON_R4(c), &err));
02557       break;
02558     case FROM_TO(MTYPE_I8, MTYPE_FQ):
02559       TCON_R16(r) = RQ_To_R16(__c_q_flotk(TCON_I8(c), &err));
02560       break;
02561     case FROM_TO(MTYPE_I4, MTYPE_FQ):
02562     case FROM_TO(MTYPE_I2, MTYPE_FQ):
02563     case FROM_TO(MTYPE_I1, MTYPE_FQ):
02564       TCON_R16(r) = RQ_To_R16(__c_q_flotj(TCON_v0(c), &err));
02565       break;
02566     case FROM_TO(MTYPE_U8, MTYPE_FQ):
02567       TCON_R16(r) = RQ_To_R16(__c_q_flotku(TCON_U8(c), &err));
02568       break;
02569     case FROM_TO(MTYPE_U4, MTYPE_FQ):
02570     case FROM_TO(MTYPE_U2, MTYPE_FQ):
02571     case FROM_TO(MTYPE_U1, MTYPE_FQ):
02572       TCON_R16(r) = RQ_To_R16(__c_q_flotju(TCON_u0(c), &err));
02573       break;
02574     case FROM_TO(MTYPE_FQ, MTYPE_C8):
02575       TCON_R8(r) = __c_dble_q(R16_To_RQ(TCON_R16(c)), &err);
02576       TCON_IR8(r) = 0.0;
02577       break;
02578     case FROM_TO(MTYPE_FQ, MTYPE_C4):
02579       Set_TCON_R4(r, __c_sngl_q(R16_To_RQ(TCON_R16(c)), &err));
02580       TCON_IR4(r) = 0.0;
02581       break;
02582     case FROM_TO(MTYPE_FQ, MTYPE_F8):
02583       TCON_R8(r) = __c_dble_q(R16_To_RQ(TCON_R16(c)), &err);
02584       break;
02585     case FROM_TO(MTYPE_FQ, MTYPE_F4):
02586       Set_TCON_R4(r, __c_sngl_q(R16_To_RQ(TCON_R16(c)), &err));
02587       break;
02588    case FROM_TO(MTYPE_FQ, MTYPE_I8):
02589       TCON_I8(r) = __c_ki_qint(R16_To_RQ(TCON_R16(c)), &err);
02590       break;
02591     case FROM_TO(MTYPE_FQ, MTYPE_I4):
02592     case FROM_TO(MTYPE_FQ, MTYPE_I2):
02593     case FROM_TO(MTYPE_FQ, MTYPE_I1):
02594       TCON_v0(r) = __c_ji_qint(R16_To_RQ(TCON_R16(c)), &err);
02595       break;
02596     case FROM_TO(MTYPE_FQ, MTYPE_U8):
02597       TCON_U8(r) = __c_ki_quint(R16_To_RQ(TCON_R16(c)), &err);
02598       break;
02599     case FROM_TO(MTYPE_FQ, MTYPE_U4):
02600     case FROM_TO(MTYPE_FQ, MTYPE_U2):
02601     case FROM_TO(MTYPE_FQ, MTYPE_U1):
02602       TCON_u0(r) = __c_ji_quint(R16_To_RQ(TCON_R16(c)), &err);
02603       break;
02604 #endif /* TARG_NEEDS_QUAD_OPS */
02605 
02606     case FROM_TO(MTYPE_C10, MTYPE_F10):
02607       TCON_R16(r) = TCON_R16(c);
02608       break;
02609     case FROM_TO(MTYPE_C8, MTYPE_F10):
02610     case FROM_TO(MTYPE_F8, MTYPE_F10):
02611       TCON_R16(r) = TCON_R8(c);
02612       break;
02613     case FROM_TO(MTYPE_C4, MTYPE_F10):
02614     case FROM_TO(MTYPE_F4, MTYPE_F10):
02615       TCON_R16(r) = TCON_R4(c);
02616       break;
02617     case FROM_TO(MTYPE_I8, MTYPE_F10):
02618       TCON_R16(r) = TCON_I8(c);
02619       break;
02620     case FROM_TO(MTYPE_U8, MTYPE_F10):
02621       TCON_R16(r) = TCON_U8(c);
02622       break;
02623     case FROM_TO(MTYPE_I4, MTYPE_F10):
02624     case FROM_TO(MTYPE_I2, MTYPE_F10):
02625     case FROM_TO(MTYPE_I1, MTYPE_F10):
02626       TCON_R16(r) = TCON_v0(c);
02627       break;
02628     case FROM_TO(MTYPE_U4, MTYPE_F10):
02629     case FROM_TO(MTYPE_U2, MTYPE_F10):
02630     case FROM_TO(MTYPE_U1, MTYPE_F10):
02631       TCON_R16(r) = TCON_u0(c);
02632       break;
02633 
02634     case FROM_TO(MTYPE_C8, MTYPE_C10):
02635       TCON_R16(r) = TCON_R8(c);
02636       TCON_IR16(r) = TCON_IR8(c);
02637       break;
02638     case FROM_TO(MTYPE_C4, MTYPE_C10):
02639       TCON_R16(r) = TCON_R4(c);
02640       TCON_IR16(r) = TCON_IR4(c);
02641       break;
02642     case FROM_TO(MTYPE_F10, MTYPE_C10):
02643       TCON_R16(r) = TCON_R16(c);
02644       TCON_IR16(r) = 0.0L;
02645       break;
02646     case FROM_TO(MTYPE_F8, MTYPE_C10):
02647       TCON_R16(r) = TCON_R8(c);
02648       TCON_IR16(r) = 0.0L;
02649       break;
02650     case FROM_TO(MTYPE_F4, MTYPE_C10):
02651       TCON_R16(r) = TCON_R4(c);
02652       TCON_IR16(r) = 0.0L;
02653       break;
02654     case FROM_TO(MTYPE_I8, MTYPE_C10):
02655       TCON_R16(r) = TCON_I8(c);
02656       TCON_IR16(r) = 0.0L;
02657       break;
02658     case FROM_TO(MTYPE_U8, MTYPE_C10):
02659       TCON_R16(r) = TCON_U8(c);
02660       TCON_IR16(r) = 0.0L;
02661       break;
02662     case FROM_TO(MTYPE_I4, MTYPE_C10):
02663     case FROM_TO(MTYPE_I2, MTYPE_C10):
02664     case FROM_TO(MTYPE_I1, MTYPE_C10):
02665       TCON_R16(r) = TCON_v0(c);
02666       TCON_IR16(r) = 0.0L;
02667       break;
02668     case FROM_TO(MTYPE_U4, MTYPE_C10):
02669     case FROM_TO(MTYPE_U2, MTYPE_C10):
02670     case FROM_TO(MTYPE_U1, MTYPE_C10):
02671       TCON_R16(r) = TCON_u0(c);
02672       TCON_IR16(r) = 0.0L;
02673       break;
02674 
02675     case FROM_TO(MTYPE_C10, MTYPE_F8):
02676     case FROM_TO(MTYPE_F10, MTYPE_F8):
02677       TCON_R8(r) = TCON_R16(c);
02678       break;
02679     case FROM_TO(MTYPE_C8, MTYPE_F8):
02680       TCON_R8(r) = TCON_R8(c);
02681       break;
02682     case FROM_TO(MTYPE_C4, MTYPE_F8):
02683     case FROM_TO(MTYPE_F4, MTYPE_F8):
02684       TCON_R8(r) = TCON_R4(c);
02685       break;
02686     case FROM_TO(MTYPE_I8, MTYPE_F8):
02687       TCON_R8(r) = TCON_I8(c);
02688       break;
02689     case FROM_TO(MTYPE_U8, MTYPE_F8):
02690       TCON_R8(r) = TCON_U8(c);
02691       break;
02692     case FROM_TO(MTYPE_I4, MTYPE_F8):
02693     case FROM_TO(MTYPE_I2, MTYPE_F8):
02694     case FROM_TO(MTYPE_I1, MTYPE_F8):
02695       TCON_R8(r) = TCON_v0(c);
02696       break;
02697     case FROM_TO(MTYPE_U4, MTYPE_F8):
02698     case FROM_TO(MTYPE_U2, MTYPE_F8):
02699     case FROM_TO(MTYPE_U1, MTYPE_F8):
02700       TCON_R8(r) = TCON_u0(c);
02701       break;
02702 
02703     case FROM_TO(MTYPE_C10, MTYPE_C8):
02704       TCON_R8(r) = TCON_R16(c);
02705       TCON_IR8(r) = TCON_IR16(c);
02706       break;
02707     case FROM_TO(MTYPE_C4, MTYPE_C8):
02708       TCON_R8(r) = TCON_R4(c);
02709       TCON_IR8(r) = TCON_IR4(c);
02710       break;
02711     case FROM_TO(MTYPE_F10, MTYPE_C8):
02712       TCON_R8(r) = TCON_R16(c);
02713       TCON_IR8(r) = 0.0;
02714       break;
02715     case FROM_TO(MTYPE_F8, MTYPE_C8):
02716       TCON_R8(r) = TCON_R8(c);
02717       TCON_IR8(r) = 0.0;
02718       break;
02719     case FROM_TO(MTYPE_F4, MTYPE_C8):
02720       TCON_R8(r) = TCON_R4(c);
02721       TCON_IR8(r) = 0.0;
02722       break;
02723     case FROM_TO(MTYPE_I8, MTYPE_C8):
02724       TCON_R8(r) = TCON_I8(c);
02725       TCON_IR8(r) = 0.0;
02726       break;
02727     case FROM_TO(MTYPE_U8, MTYPE_C8):
02728       TCON_R8(r) = TCON_U8(c);
02729       TCON_IR8(r) = 0.0;
02730       break;
02731     case FROM_TO(MTYPE_I4, MTYPE_C8):
02732     case FROM_TO(MTYPE_I2, MTYPE_C8):
02733     case FROM_TO(MTYPE_I1, MTYPE_C8):
02734       TCON_R8(r) = TCON_v0(c);
02735       TCON_IR8(r) = 0.0;
02736       break;
02737     case FROM_TO(MTYPE_U4, MTYPE_C8):
02738     case FROM_TO(MTYPE_U2, MTYPE_C8):
02739     case FROM_TO(MTYPE_U1, MTYPE_C8):
02740       TCON_R8(r) = TCON_u0(c);
02741       TCON_IR8(r) = 0.0;
02742       break;
02743 
02744     case FROM_TO(MTYPE_C10, MTYPE_F4):
02745     case FROM_TO(MTYPE_F10, MTYPE_F4):
02746       Set_TCON_R4(r, TCON_R16(c));
02747       break;
02748     case FROM_TO(MTYPE_C8, MTYPE_F4):
02749     case FROM_TO(MTYPE_F8, MTYPE_F4):
02750       TCON_R4(r) = TCON_R8(c);
02751       break;
02752     case FROM_TO(MTYPE_C4, MTYPE_F4):
02753       TCON_R4(r) = TCON_R4(c);
02754       break;
02755     case FROM_TO(MTYPE_I8, MTYPE_F4):
02756       TCON_R4(r) = TCON_I8(c);
02757       break;
02758     case FROM_TO(MTYPE_U8, MTYPE_F4):
02759       TCON_R4(r) = TCON_U8(c);
02760       break;
02761     case FROM_TO(MTYPE_I4, MTYPE_F4):
02762     case FROM_TO(MTYPE_I2, MTYPE_F4):
02763     case FROM_TO(MTYPE_I1, MTYPE_F4):
02764       TCON_R4(r) = TCON_v0(c);
02765       break;
02766     case FROM_TO(MTYPE_U4, MTYPE_F4):
02767     case FROM_TO(MTYPE_U2, MTYPE_F4):
02768     case FROM_TO(MTYPE_U1, MTYPE_F4):
02769       TCON_R4(r) = TCON_u0(c);
02770       break;
02771 
02772     case FROM_TO(MTYPE_C10, MTYPE_C4):
02773       TCON_R4(r) = TCON_R16(c);
02774       TCON_IR4(r) = TCON_IR16(c);
02775       break;
02776     case FROM_TO(MTYPE_C8, MTYPE_C4):
02777       TCON_R4(r) = TCON_R8(c);
02778       TCON_IR4(r) = TCON_IR8(c);
02779       break;
02780     case FROM_TO(MTYPE_F10, MTYPE_C4):
02781       Set_TCON_R4(r, TCON_R16(c));
02782       TCON_IR4(r) = 0.0;
02783       break;
02784     case FROM_TO(MTYPE_F8, MTYPE_C4):
02785       TCON_R4(r) = TCON_R8(c);
02786       TCON_IR4(r) = 0.0;
02787       break;
02788     case FROM_TO(MTYPE_F4, MTYPE_C4):
02789       TCON_R4(r) = TCON_R4(c);
02790       TCON_IR4(r) = 0.0;
02791       break;
02792     case FROM_TO(MTYPE_I8, MTYPE_C4):
02793       TCON_R4(r) = TCON_I8(c);
02794       TCON_IR4(r) = 0.0;
02795       break;
02796     case FROM_TO(MTYPE_U8, MTYPE_C4):
02797       TCON_R4(r) = TCON_U8(c);
02798       TCON_IR4(r) = 0.0;
02799       break;
02800     case FROM_TO(MTYPE_I4, MTYPE_C4):
02801     case FROM_TO(MTYPE_I2, MTYPE_C4):
02802     case FROM_TO(MTYPE_I1, MTYPE_C4):
02803       TCON_R4(r) = TCON_v0(c);
02804       TCON_IR4(r) = 0.0;
02805       break;
02806     case FROM_TO(MTYPE_U4, MTYPE_C4):
02807     case FROM_TO(MTYPE_U2, MTYPE_C4):
02808     case FROM_TO(MTYPE_U1, MTYPE_C4):
02809       TCON_R4(r) = TCON_u0(c);
02810       TCON_IR4(r) = 0.0;
02811       break;
02812 
02813     case FROM_TO(MTYPE_C10, MTYPE_I8):
02814     case FROM_TO(MTYPE_F10, MTYPE_I8):
02815       TCON_I8(r) = (INT64)TCON_R16(c);
02816       break;
02817     case FROM_TO(MTYPE_C8, MTYPE_I8):
02818     case FROM_TO(MTYPE_F8, MTYPE_I8):
02819       TCON_I8(r) = (INT64)TCON_R8(c);
02820       break;
02821     case FROM_TO(MTYPE_C4, MTYPE_I8):
02822     case FROM_TO(MTYPE_F4, MTYPE_I8):
02823       TCON_I8(r) = (INT64)TCON_R4(c);
02824       break;
02825     case FROM_TO(MTYPE_U8, MTYPE_I8):
02826       TCON_I8(r) = TCON_U8(c);
02827       break;
02828     case FROM_TO(MTYPE_I4, MTYPE_I8):
02829     case FROM_TO(MTYPE_I2, MTYPE_I8):
02830     case FROM_TO(MTYPE_I1, MTYPE_I8):
02831     case FROM_TO(MTYPE_B, MTYPE_I8):
02832       TCON_I8(r) = TCON_v0(c);
02833       break;
02834     case FROM_TO(MTYPE_U4, MTYPE_I8):
02835     case FROM_TO(MTYPE_U2, MTYPE_I8):
02836     case FROM_TO(MTYPE_U1, MTYPE_I8):
02837       TCON_I8(r) = TCON_u0(c);
02838       break;
02839 
02840     case FROM_TO(MTYPE_C10, MTYPE_U8):
02841     case FROM_TO(MTYPE_F10, MTYPE_U8):
02842       TCON_U8(r) = (UINT64)TCON_R16(c);
02843       break;
02844     case FROM_TO(MTYPE_C8, MTYPE_U8):
02845     case FROM_TO(MTYPE_F8, MTYPE_U8):
02846       TCON_U8(r) = (UINT64)TCON_R8(c);
02847       break;
02848     case FROM_TO(MTYPE_C4, MTYPE_U8):
02849     case FROM_TO(MTYPE_F4, MTYPE_U8):
02850       TCON_U8(r) = (UINT64)TCON_R4(c);
02851       break;
02852     case FROM_TO(MTYPE_I8, MTYPE_U8):
02853       TCON_U8(r) = TCON_I8(c);
02854       break;
02855     case FROM_TO(MTYPE_I4, MTYPE_U8):
02856     case FROM_TO(MTYPE_I2, MTYPE_U8):
02857     case FROM_TO(MTYPE_I1, MTYPE_U8):
02858     case FROM_TO(MTYPE_B, MTYPE_U8):
02859       TCON_U8(r) = TCON_v0(c);
02860       break;
02861     case FROM_TO(MTYPE_U4, MTYPE_U8):
02862     case FROM_TO(MTYPE_U2, MTYPE_U8):
02863     case FROM_TO(MTYPE_U1, MTYPE_U8):
02864       TCON_U8(r) = TCON_u0(c);
02865       break;
02866 
02867     case FROM_TO(MTYPE_C10, MTYPE_I4):
02868     case FROM_TO(MTYPE_F10, MTYPE_I4):
02869       TCON_v0(r) = (INT32)TCON_R16(c);
02870       break;
02871     case FROM_TO(MTYPE_C8, MTYPE_I4):
02872     case FROM_TO(MTYPE_F8, MTYPE_I4):
02873       TCON_v0(r) = (INT32)TCON_R8(c);
02874       break;
02875     case FROM_TO(MTYPE_C4, MTYPE_I4):
02876     case FROM_TO(MTYPE_F4, MTYPE_I4):
02877       TCON_v0(r) = (INT32)TCON_R4(c);
02878       break;
02879     case FROM_TO(MTYPE_I8, MTYPE_I4):
02880       TCON_v0(r) = TCON_I8(c);
02881       break;
02882     case FROM_TO(MTYPE_U8, MTYPE_I4):
02883       TCON_v0(r) = TCON_U8(c);
02884       break;
02885     case FROM_TO(MTYPE_U4, MTYPE_I4):
02886     case FROM_TO(MTYPE_I2, MTYPE_I4):
02887     case FROM_TO(MTYPE_U2, MTYPE_I4):
02888     case FROM_TO(MTYPE_I1, MTYPE_I4):
02889     case FROM_TO(MTYPE_U1, MTYPE_I4):
02890     case FROM_TO(MTYPE_B, MTYPE_I4):
02891       TCON_v0(r) = TCON_v0(c);
02892       break;
02893 
02894     case FROM_TO(MTYPE_C10, MTYPE_U4):
02895     case FROM_TO(MTYPE_F10, MTYPE_U4):
02896       TCON_u0(r) = (UINT32)TCON_R16(c);
02897       break;
02898     case FROM_TO(MTYPE_C8, MTYPE_U4):
02899     case FROM_TO(MTYPE_F8, MTYPE_U4):
02900       TCON_u0(r) = (UINT32)TCON_R8(c);
02901       break;
02902     case FROM_TO(MTYPE_C4, MTYPE_U4):
02903     case FROM_TO(MTYPE_F4, MTYPE_U4):
02904       TCON_u0(r) = (UINT32)TCON_R4(c);
02905       break;
02906     case FROM_TO(MTYPE_I8, MTYPE_U4):
02907       TCON_u0(r) = TCON_I8(c);
02908       break;
02909     case FROM_TO(MTYPE_U8, MTYPE_U4):
02910       TCON_u0(r) = TCON_U8(c);
02911       break;
02912     case FROM_TO(MTYPE_I4, MTYPE_U4):
02913     case FROM_TO(MTYPE_I2, MTYPE_U4):
02914     case FROM_TO(MTYPE_U2, MTYPE_U4):
02915     case FROM_TO(MTYPE_I1, MTYPE_U4):
02916     case FROM_TO(MTYPE_U1, MTYPE_U4):
02917     case FROM_TO(MTYPE_B, MTYPE_U4):
02918       TCON_v0(r) = TCON_v0(c);
02919       break;
02920 
02921     case FROM_TO(MTYPE_C10, MTYPE_I2):
02922     case FROM_TO(MTYPE_F10, MTYPE_I2):
02923       TCON_v0(r) = (INT32)TCON_R16(c);
02924       break;
02925     case FROM_TO(MTYPE_C8, MTYPE_I2):
02926     case FROM_TO(MTYPE_F8, MTYPE_I2):
02927       TCON_v0(r) = (INT32)TCON_R8(c);
02928       break;
02929     case FROM_TO(MTYPE_C4, MTYPE_I2):
02930     case FROM_TO(MTYPE_F4, MTYPE_I2):
02931       TCON_v0(r) = (INT32)TCON_R4(c);
02932       break;
02933     case FROM_TO(MTYPE_I8, MTYPE_I2):
02934       TCON_v0(r) = TCON_I8(c);
02935       break;
02936     case FROM_TO(MTYPE_U8, MTYPE_I2):
02937       TCON_v0(r) = TCON_U8(c);
02938       break;
02939     case FROM_TO(MTYPE_I4, MTYPE_I2):
02940     case FROM_TO(MTYPE_U4, MTYPE_I2):
02941     case FROM_TO(MTYPE_U2, MTYPE_I2):
02942     case FROM_TO(MTYPE_I1, MTYPE_I2):
02943     case FROM_TO(MTYPE_U1, MTYPE_I2):
02944     case FROM_TO(MTYPE_B, MTYPE_I2):
02945       TCON_v0(r) = TCON_v0(c);
02946       break;
02947 
02948     case FROM_TO(MTYPE_C10, MTYPE_U2):
02949     case FROM_TO(MTYPE_F10, MTYPE_U2):
02950       TCON_u0(r) = (UINT32)TCON_R16(c);
02951       break;
02952     case FROM_TO(MTYPE_C8, MTYPE_U2):
02953     case FROM_TO(MTYPE_F8, MTYPE_U2):
02954       TCON_u0(r) = (UINT32)TCON_R8(c);
02955       break;
02956     case FROM_TO(MTYPE_C4, MTYPE_U2):
02957     case FROM_TO(MTYPE_F4, MTYPE_U2):
02958       TCON_u0(r) = (UINT32)TCON_R4(c);
02959       break;
02960     case FROM_TO(MTYPE_I8, MTYPE_U2):
02961       TCON_u0(r) = TCON_I8(c);
02962       break;
02963     case FROM_TO(MTYPE_U8, MTYPE_U2):
02964       TCON_u0(r) = TCON_U8(c);
02965       break;
02966     case FROM_TO(MTYPE_I4, MTYPE_U2):
02967     case FROM_TO(MTYPE_U4, MTYPE_U2):
02968     case FROM_TO(MTYPE_I2, MTYPE_U2):
02969     case FROM_TO(MTYPE_I1, MTYPE_U2):
02970     case FROM_TO(MTYPE_U1, MTYPE_U2):
02971     case FROM_TO(MTYPE_B, MTYPE_U2):
02972       TCON_v0(r) = TCON_v0(c);
02973       break;
02974 
02975     case FROM_TO(MTYPE_C10, MTYPE_I1):
02976     case FROM_TO(MTYPE_F10, MTYPE_I1):
02977       TCON_v0(r) = (INT32)TCON_R16(c);
02978       break;
02979     case FROM_TO(MTYPE_C8, MTYPE_I1):
02980     case FROM_TO(MTYPE_F8, MTYPE_I1):
02981       TCON_v0(r) = (INT32)TCON_R8(c);
02982       break;
02983     case FROM_TO(MTYPE_C4, MTYPE_I1):
02984     case FROM_TO(MTYPE_F4, MTYPE_I1):
02985       TCON_v0(r) = (INT32)TCON_R4(c);
02986       break;
02987     case FROM_TO(MTYPE_I8, MTYPE_I1):
02988       TCON_v0(r) = TCON_I8(c);
02989       break;
02990     case FROM_TO(MTYPE_U8, MTYPE_I1):
02991       TCON_v0(r) = TCON_U8(c);
02992       break;
02993     case FROM_TO(MTYPE_I4, MTYPE_I1):
02994     case FROM_TO(MTYPE_U4, MTYPE_I1):
02995     case FROM_TO(MTYPE_I2, MTYPE_I1):
02996     case FROM_TO(MTYPE_U2, MTYPE_I1):
02997     case FROM_TO(MTYPE_U1, MTYPE_I1):
02998     case FROM_TO(MTYPE_B, MTYPE_I1):
02999       TCON_v0(r) = TCON_v0(c);
03000       break;
03001 
03002     case FROM_TO(MTYPE_C10, MTYPE_U1):
03003     case FROM_TO(MTYPE_F10, MTYPE_U1):
03004       TCON_u0(r) = (UINT32)TCON_R16(c);
03005       break;
03006     case FROM_TO(MTYPE_C8, MTYPE_U1):
03007     case FROM_TO(MTYPE_F8, MTYPE_U1):
03008       TCON_u0(r) = (UINT32)TCON_R8(c);
03009       break;
03010     case FROM_TO(MTYPE_C4, MTYPE_U1):
03011     case FROM_TO(MTYPE_F4, MTYPE_U1):
03012       TCON_u0(r) = (UINT32)TCON_R4(c);
03013       break;
03014     case FROM_TO(MTYPE_I8, MTYPE_U1):
03015       TCON_u0(r) = TCON_I8(c);
03016       break;
03017     case FROM_TO(MTYPE_U8, MTYPE_U1):
03018       TCON_u0(r) = TCON_U8(c);
03019       break;
03020     case FROM_TO(MTYPE_I4, MTYPE_U1):
03021     case FROM_TO(MTYPE_U4, MTYPE_U1):
03022     case FROM_TO(MTYPE_I2, MTYPE_U1):
03023     case FROM_TO(MTYPE_U2, MTYPE_U1):
03024     case FROM_TO(MTYPE_I1, MTYPE_U1):
03025     case FROM_TO(MTYPE_B, MTYPE_U1):
03026       TCON_v0(r) = TCON_v0(c);
03027       break;
03028 
03029     case FROM_TO(MTYPE_I8, MTYPE_B):
03030       TCON_u0(r) = TCON_I8(c);
03031       break;
03032     case FROM_TO(MTYPE_U8, MTYPE_B):
03033       TCON_u0(r) = TCON_U8(c);
03034       break;
03035     case FROM_TO(MTYPE_I4, MTYPE_B):
03036     case FROM_TO(MTYPE_U4, MTYPE_B):
03037     case FROM_TO(MTYPE_I2, MTYPE_B):
03038     case FROM_TO(MTYPE_U2, MTYPE_B):
03039     case FROM_TO(MTYPE_I1, MTYPE_B):
03040     case FROM_TO(MTYPE_U1, MTYPE_B):
03041       TCON_v0(r) = TCON_v0(c);
03042       break;
03043 
03044     default:
03045       Is_True ( FALSE, ( "Targ-Conv can not convert from %s to %s",
03046         Mtype_Name(ty_from), Mtype_Name(ty_to) ) );
03047   }
03048   TCON_ty(r) = ty_to;
03049   return r;
03050 } /* Targ_Conv */
03051 
03052 #ifndef MONGOOSE_BE
03053 /* ====================================================================
03054  *
03055  * Targ_Atoll
03056  *
03057  * Convert an ASCII number representation to an INT64.  If it fits,
03058  * put it in i64 and return TRUE.  If not, truncate it into i64 and
03059  * return FALSE.
03060  *
03061  * WARNING:  sgned must be 0 or 1.
03062  *
03063  * ====================================================================
03064  */
03065 
03066 static BOOL
03067 Targ_Atoll ( char *str, INT64 *i64, BOOL sgned )
03068 {
03069   UINT64 m, d;
03070   UINT64 mhi, mlo;
03071   INT16 digits;
03072   BOOL neg = FALSE;
03073   BOOL valid = TRUE;
03074 
03075   if ( *str == '-' ) {
03076     neg = TRUE;
03077     str++;
03078   }
03079 
03080   m = 0;
03081   digits = 0;
03082   while ( *str ) {
03083     d = *str - '0';
03084     if ( valid && ++digits >= 19 ) {
03085       /* Check for overflow before proceeding: */
03086       mhi = (UINT32) (m >> 32);
03087       mlo = (UINT32) m;
03088       mlo = 10 * mlo + d;
03089       mhi *= 10;
03090       if ( mlo > UINT32_MAX ) {
03091   mhi += mlo >> 32;
03092       }
03093       if ( ( sgned && mhi > INT32_MAX+(neg) ) ||
03094      ( ! sgned && mhi > UINT32_MAX ) )
03095       {
03096   valid = FALSE;
03097       }
03098     }
03099     m = 10 * m + d;
03100     str++;
03101   }
03102 
03103   *i64 = neg ? -(INT64)m : (INT64)m;
03104   return valid;
03105 } /* Targ_Atoll */
03106 
03107 /* ====================================================================
03108  *
03109  * Targ_Atoc
03110  *
03111  * Convert an ASCII number representation to a TCON of the given mtype.
03112  *
03113  * ====================================================================
03114  */
03115 
03116 TCON
03117 Targ_Atoc ( TYPE_ID ty, char *str )
03118 {
03119   static TCON c;
03120   INT64 m;
03121 #if !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS))
03122   char *sstr;
03123 #endif /* !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS)) */
03124   INT err;
03125 
03126   TCON_ty(c) = ty;
03127   TCON_v0(c) = 0;
03128   TCON_v1(c) = 0;
03129   TCON_v2(c) = 0;
03130   TCON_v3(c) = 0;
03131 
03132   switch (ty) {
03133 
03134     case MTYPE_I1:
03135       if ( ! Targ_Atoll ( str, &m, TRUE ) ||
03136      m > SCHAR_MAX ||
03137      m < SCHAR_MIN )
03138       {
03139   ErrMsg ( EC_Large_Const, str );
03140       }
03141       TCON_v0(c) = m;
03142       TCON_v1(c) = 0;
03143       break;
03144 
03145     case MTYPE_I2:
03146       if ( ! Targ_Atoll ( str, &m, TRUE ) ||
03147      m > INT16_MAX ||
03148      m < INT16_MIN )
03149       {
03150   ErrMsg ( EC_Large_Const, str );
03151       }
03152       TCON_v0(c) = m;
03153       TCON_v1(c) = 0;
03154       break;
03155 
03156     case MTYPE_I4:
03157       if ( ! Targ_Atoll ( str, &m, TRUE ) ||
03158      m > INT32_MAX ||
03159      m < INT32_MIN )
03160       {
03161   ErrMsg ( EC_Large_Const, str );
03162       }
03163       TCON_v0(c) = m;
03164       TCON_v1(c) = 0;
03165       break;
03166 
03167     case MTYPE_I8:
03168       if ( ! Targ_Atoll ( str, &m, TRUE ) ) {
03169   ErrMsg ( EC_Large_Const, str );
03170       }
03171       TCON_I8(c) = m;
03172       break;
03173 
03174     case MTYPE_U1:
03175       if ( ! Targ_Atoll ( str, &m, FALSE ) ||
03176      (UINT64) m > UCHAR_MAX )
03177       {
03178   ErrMsg ( EC_Large_Const, str );
03179       }
03180       TCON_u0(c) = (UINT8) m;
03181       TCON_u1(c) = 0;
03182       break;
03183 
03184     case MTYPE_U2:
03185       if ( ! Targ_Atoll ( str, &m, FALSE ) ||
03186      (UINT64) m > UINT16_MAX )
03187       {
03188   ErrMsg ( EC_Large_Const, str );
03189       }
03190       TCON_u0(c) = (UINT16) m;
03191       TCON_u1(c) = 0;
03192       break;
03193 
03194     case MTYPE_U4:
03195       if ( ! Targ_Atoll ( str, &m, FALSE ) ||
03196      (UINT64) m > UINT32_MAX )
03197       {
03198   ErrMsg ( EC_Large_Const, str );
03199       }
03200       TCON_u0(c) = (UINT32) m;
03201       TCON_u1(c) = 0;
03202       break;
03203 
03204     case MTYPE_U8:
03205       if ( ! Targ_Atoll ( str, &m, FALSE ) ) {
03206   ErrMsg ( EC_Large_Const, str );
03207       }
03208       TCON_U8(c) = (UINT64) m;
03209       break;
03210 
03211     case MTYPE_F4:
03212       /* TODO: do these carefully, taking care of overflow */
03213 /* Do this the right way      * ((float *) &TCON_v0(c)) = atof(str); */
03214       TCON_R4(c) = atof(str);
03215       TCON_v0(c) = 0;
03216       break;
03217 
03218     case MTYPE_F8:
03219 #if !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS))
03220       for ( sstr = str; *sstr; sstr++ ) {
03221   if (*sstr == 'd' || *sstr == 'D') {
03222     *sstr='E';
03223     break;
03224   }
03225       }
03226 #endif /* !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS)) */
03227  /* Do this the right way     * ((double *) &TCON_v0(c)) = atof(str); */
03228       TCON_R8(c) = atof(str);
03229       break;
03230 
03231     case MTYPE_FQ:
03232 #if !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS))
03233       for ( sstr = str; *sstr; sstr++ ) {
03234   if (*sstr == 'q' || *sstr == 'Q') {
03235     *sstr='E';
03236     break;
03237   }
03238       }
03239 #endif /* !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS)) */
03240       /* TODO: add errror checking */
03241       TCON_R16(c) = RQ_To_R16(__c_a_to_q(str, &err));
03242       
03243       break;
03244 
03245     default:
03246       ErrMsg ( EC_Inv_Mtype, Mtype_Name(ty), "Targ_Atoc" );
03247   }
03248   return c;
03249 } /* Targ_Atoc */
03250 #endif /* MONGOOSE_BE */
03251 
03252 /* ====================================================================
03253  *
03254  * Targ_Hexfptoc
03255  *
03256  * Convert an ASCII number representation of a floating-point hexadecimal
03257  * constant to a TCON of the given mtype.  The input string must be a
03258  * valid hexadecimal number.  Its length must be 32 digits for MTYPE_FQ,
03259  * 16 digits for MTYPE_F8, or 8 digits for MTYPE_F4.  These restrictions
03260  * are assumed correct and are not checked by this function!
03261  *
03262  * ====================================================================
03263  */
03264 
03265 TCON
03266 Targ_Hexfptoc(const TYPE_ID ty, const char * const str)
03267 {
03268   static TCON c;
03269   char ac[9];
03270 
03271   TCON_ty(c) = ty;
03272   TCON_u1(c) = 0;
03273   TCON_u0(c) = 0;
03274   TCON_u3(c) = 0;
03275   TCON_u2(c) = 0;
03276   /* Set the null character in the string argument for strtoul.  All
03277      strings will have 8 characters. */
03278   ac[8] = '\0';
03279   switch (ty) {
03280     case MTYPE_FQ:
03281       strncpy(ac, str+24, 8);
03282       TCON_u2(c) = strtoul(ac, (char **)NULL, 16);
03283       strncpy(ac, str+16, 8);
03284       TCON_u3(c) = strtoul(ac, (char **)NULL, 16);
03285       /* FALL THROUGH */
03286     case MTYPE_F8:
03287       strncpy(ac, str+8, 8);
03288       TCON_u0(c) = strtoul(ac, (char **)NULL, 16);
03289       /* FALL THROUGH */
03290     case MTYPE_F4:
03291       strncpy(ac, str, 8);
03292       TCON_u1(c) = strtoul(ac, (char **)NULL, 16);
03293       break;
03294     default:
03295       ErrMsg(EC_Inv_Mtype, Mtype_Name(ty), "Targ_Hexfptoc");
03296   }
03297   return c;
03298 } /* Targ_Hexfptoc */
03299 
03300 /* ====================================================================
03301  *
03302  * Targ_Print
03303  *
03304  * Convert constant c to a character string. if fmt is given, it is 
03305  * used as the printf fmt, else a default fmt is provided. The returning
03306  * ptr points to a static array which gets recycled after TPB_SIZE calls.
03307  *
03308  * WARNING: TO BE USED ONLY FOR DIAGNOSTICS.
03309  *
03310  * ====================================================================
03311  */
03312 
03313 char *
03314 Targ_Print (const char *fmt, TCON c )
03315 {
03316    INT slen,i;
03317    char *bytes;
03318    INT spos;
03319    BOOL string_as_bytes;
03320 
03321    struct tpb {
03322       char buf[1024];
03323    };
03324 #define TPB_SIZE 8
03325    static struct tpb tpbuf[8];
03326    static INT tpidx = 0;
03327 #if !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS))
03328    char *re;
03329 #endif /* !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS)) */
03330    char *r;
03331 
03332    r = tpbuf[tpidx].buf;
03333    tpidx = (tpidx + 1) & 7;
03334    switch (TCON_ty(c)) {
03335     case MTYPE_STRING:
03336       /* Since in F90 strings may be used to represent byte strings,
03337        * we will use two slightly different methods for displaying them.
03338        */
03339       slen = TCON_len(c);
03340       bytes = Index_to_char_array (TCON_cp(c));
03341       string_as_bytes = FALSE;
03342       for (i = 0; i < slen-1; i++) {
03343    if (bytes[i] == '\0') {
03344       string_as_bytes = TRUE;
03345       break;
03346    }
03347       }
03348       if (string_as_bytes) {
03349    spos = 0;
03350    spos = sprintf(r,"(%d hex bytes) ",slen);
03351    for (i=0; i < slen && spos < 1000; i++) {
03352       if (i == slen-1) {
03353          spos += sprintf(r+spos,"%x",bytes[i]);
03354       } else {
03355          spos += sprintf(r+spos,"%x, ",bytes[i]);
03356       }
03357    }
03358    if (i < slen) {
03359       sprintf(r+spos,"...");
03360    }
03361       } else {
03362    sprintf(r, "(%d bytes) \"", slen);
03363    char *t = r + strlen (r);
03364          char *s = r + 1000;
03365    for (i = 0; i < slen && t < s; i++) {
03366     t = Targ_Append_To_Dbuf (t, bytes[i]);
03367          }
03368    if (i < slen) {
03369       sprintf(t,"...\"");
03370    } else {
03371       sprintf(t, "\"");
03372    }
03373       }
03374       break;
03375 
03376     case MTYPE_B:
03377     case MTYPE_I1:
03378     case MTYPE_I2:
03379     case MTYPE_I4:
03380     case MTYPE_U1:
03381     case MTYPE_U2:
03382     case MTYPE_U4:
03383       if (fmt == NULL) fmt = "%1d";
03384       sprintf(r, fmt, TCON_v0(c));
03385       break;
03386 
03387     case MTYPE_I8:
03388     case MTYPE_U8:
03389       if (fmt == NULL) fmt = "%1lld";
03390       sprintf(r, fmt, TCON_I8(c));
03391       break;
03392 
03393     case MTYPE_F4:
03394       if (fmt == NULL) fmt = "%#12.7g";
03395         sprintf(r, fmt, TCON_R4(c));
03396 #if !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS))
03397       if (re = strchr(r, 'e'))
03398   *re = 'd';
03399 #endif /* !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS)) */
03400       break;
03401 
03402     case MTYPE_F8:
03403       if (fmt == NULL) fmt = "%#21.16g";
03404         sprintf(r, fmt, TCON_R8(c));
03405 #if !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS))
03406       if (re = strchr(r, 'e'))
03407   *re = 'd';
03408 #endif /* !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS)) */
03409       break;
03410 
03411     case MTYPE_F10:
03412       if (fmt == NULL) fmt = "%Lg";
03413         sprintf(r, fmt, TCON_R16(c));
03414 #if !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS))
03415       if (re = strchr(r, 'e'))
03416         *re = 'd';
03417 #endif /* !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS)) */
03418       break;
03419 
03420 #ifdef TARG_NEEDS_QUAD_OPS
03421     case MTYPE_FQ:
03422       {
03423    INT dummy_err;
03424    QUAD q = R16_To_RQ(TCON_R16(c));
03425    /*
03426       In Fortran, a user can specify an illegal quad constant
03427       using VMS-style bit constants, so we should just give
03428       a warning.
03429       */
03430    if ( q.hi == 0.0 && q.lo != 0.0)
03431      ErrMsg( EC_Ill_Quad_Const, TCON_u0(c), TCON_u1(c), TCON_u2(c), TCON_u3(c));
03432    __c_q_to_a(r, q, &dummy_err);
03433 #if !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS))
03434    if (re = strchr(r, 'e'))
03435      *re = 'd';
03436 #endif /* !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS)) */
03437       }
03438       break;
03439 #endif
03440 
03441     case MTYPE_C4:
03442       if (fmt == NULL) fmt = "%#12.7g, %#12.7g";
03443       sprintf(r, fmt, TCON_R4(c), TCON_IR4(c));
03444 #if !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS))
03445       if (re = strchr(r, 'e'))
03446   *re = 'd';
03447       if (re = strrchr(r, 'e'))
03448   *re = 'd';
03449 #endif /* !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS)) */
03450       break;
03451 
03452     case MTYPE_C8:
03453       if (fmt == NULL) fmt = "%#21.16g, %#21.16g";
03454       sprintf(r, fmt, TCON_R8(c), TCON_IR8(c));
03455 #if !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS))
03456       if (re = strchr(r, 'e'))
03457   *re = 'd';
03458       if (re = strrchr(r, 'e'))
03459   *re = 'd';
03460 #endif /* !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS)) */
03461       break;
03462 
03463     case MTYPE_C10:
03464       if (fmt == NULL)
03465   fmt = "%#21.16Lg, %#21.16Lg";
03466       sprintf(r, fmt, TCON_R16(c), TCON_IR16(c));
03467 #if !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS))
03468       if (re = strchr(r, 'e'))
03469   *re = 'd';
03470       if (re = strrchr(r, 'e'))
03471   *re = 'd';
03472 #endif /* !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS)) */
03473       break;
03474 
03475 #ifdef TARG_NEEDS_QUAD_OPS
03476     case MTYPE_CQ:
03477       {
03478    INT dummy_err;
03479    INT l;
03480    QUAD q = R16_To_RQ(TCON_R16(c));
03481    /*
03482       In Fortran, a user can specify an illegal quad constant
03483       using VMS-style bit constants, so we should just give
03484       a warning.
03485       */
03486    if ( q.hi == 0.0 && q.lo != 0.0)
03487      ErrMsg( EC_Ill_Quad_Const, TCON_u0(c), TCON_u1(c), TCON_u2(c), TCON_u3(c));
03488    __c_q_to_a(r, q, &dummy_err);
03489 #if !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS))
03490    if (re = strchr(r, 'e'))
03491      *re = 'd';
03492 #endif /* !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS)) */
03493 
03494    l = strlen(r);
03495    r [l++] = ',';
03496    r [l++] = ' ';
03497 
03498    q = R16_To_RQ(TCON_IR16(c));
03499    /*
03500       In Fortran, a user can specify an illegal quad constant
03501       using VMS-style bit constants, so we should just give
03502       a warning.
03503       */
03504    if ( q.hi == 0.0 && q.lo != 0.0)
03505      ErrMsg( EC_Ill_Quad_Const, TCON_u0(c), TCON_u1(c), TCON_u2(c), TCON_u3(c));
03506    __c_q_to_a(&r [l], q, &dummy_err);
03507 #if !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS))
03508    if (re = strchr(r, 'e'))
03509      *re = 'd';
03510 #endif /* !(defined(FRONT_END_C) || defined(FRONT_END_CPLUSPLUS)) */
03511       }
03512       break;
03513 #endif
03514 
03515     default:
03516       ErrMsg ( EC_Inv_Mtype, Mtype_Name(TCON_ty(c)), "Targ_Print" );
03517    }
03518    return r;
03519 } /* Targ_Print */
03520 
03521 INT64
03522 Targ_To_Host ( TCON c )
03523 {
03524   mINT32 i32;
03525 
03526   switch (TCON_ty(c)) {
03527     case MTYPE_B:
03528       return  (TCON_U4(c)&0x1);
03529     case MTYPE_I1:
03530       i32 = TCON_I4(c);
03531       return ((i32&0x80) ? 0xffffffffffffff00ll : 0ll) | (i32&0xff);
03532     case MTYPE_I2:
03533       i32 = TCON_I4(c);
03534       return ((i32&0x8000) ? 0xffffffffffff0000ll : 0ll) | (i32&0xffff);
03535     case MTYPE_U1:
03536       return  (TCON_U4(c)&0xff);
03537     case MTYPE_U2:
03538       return  (TCON_U4(c)&0xffff);
03539     case MTYPE_U4:
03540       return (TCON_U4(c)&0x00000000ffffffffll);
03541     case MTYPE_I4:
03542       return TCON_I4(c);
03543     case MTYPE_I8:
03544       return TCON_I8(c);
03545     case MTYPE_U8:
03546       return TCON_U8(c);
03547 
03548     default:
03549       ErrMsg ( EC_Inv_Mtype, Mtype_Name(TCON_ty(c)), "Targ_To_Host" );
03550   }
03551 
03552   return 0;
03553 } /* Targ_To_Host */
03554 
03555 #ifndef MONGOOSE_BE
03556 INT64
03557 Targ_To_Signed_Host ( TCON c )
03558 {
03559   mINT32 i32;
03560 
03561   switch (TCON_ty(c)) {
03562     case MTYPE_B:
03563       return  (TCON_U4(c)&0x1);
03564     case MTYPE_I1:
03565       i32 = TCON_I4(c);
03566       return ((i32&0x80) ? 0xffffffffffffff00ll : 0ll) | (i32&0xff);
03567     case MTYPE_I2:
03568       i32 = TCON_I4(c);
03569       return ((i32&0x8000) ? 0xffffffffffff0000ll : 0ll) | (i32&0xffff);
03570     case MTYPE_U1:
03571       return  (TCON_U4(c)&0xff);
03572     case MTYPE_U2:
03573       return  (TCON_U4(c)&0xffff);
03574     case MTYPE_U4:
03575       return TCON_I4(c); /* force it to sign extend */
03576     case MTYPE_I4:
03577       return TCON_I4(c);
03578     case MTYPE_I8:
03579       return TCON_I8(c);
03580     case MTYPE_U8:
03581       return TCON_U8(c);
03582 
03583     default:
03584       ErrMsg ( EC_Inv_Mtype, Mtype_Name(TCON_ty(c)), "Targ_To_Signed_Host" );
03585   }
03586 
03587   return 0;
03588 } /* Targ_To_Signed_Host */
03589 #endif /* MONGOOSE_BE */
03590 
03591 TCON
03592 Host_To_Targ(TYPE_ID ty, INT64 v)
03593 {
03594   static TCON c;
03595 
03596   TCON_clear(c);
03597 
03598   switch (ty) {
03599     default:
03600       ErrMsg ( EC_Inv_Mtype, Mtype_Name(ty), "Host_To_Targ" );
03601 
03602     case MTYPE_B:
03603     case MTYPE_I1:
03604     case MTYPE_I2:
03605     case MTYPE_I4:
03606     case MTYPE_U1:
03607     case MTYPE_U2:
03608     case MTYPE_U4:
03609       TCON_ty(c) = ty;
03610       TCON_I8(c) = v; /* Don't change the upper bits */
03611       return c;
03612     case MTYPE_I8:
03613     case MTYPE_U8:
03614       TCON_ty(c) = ty;
03615       TCON_I8(c) = v;
03616       return c;
03617   }
03618 } /* Host_To_Targ */
03619 
03620 
03621 TCON
03622 Host_To_Targ_Float ( TYPE_ID ty, double v )
03623 {
03624   TCON c;
03625 
03626   switch (ty) {
03627    case MTYPE_C4:
03628    case MTYPE_F4:
03629      TCON_clear(c);
03630      TCON_ty(c) = ty;
03631      Set_TCON_R4(c, v);
03632      return c;
03633 
03634    case MTYPE_C8:
03635    case MTYPE_F8:
03636      TCON_clear(c);
03637      TCON_ty(c) = ty;
03638      TCON_R8(c) = v;
03639      return c;
03640 
03641    case MTYPE_C10:
03642    case MTYPE_F10:
03643      TCON_clear(c);
03644      TCON_ty(c) = ty;
03645      TCON_R16(c) = v;
03646      return c;
03647 
03648    case MTYPE_CQ:
03649    case MTYPE_FQ:
03650      TCON_clear(c);
03651      c = Targ_Conv (MTYPE_FQ,
03652         Host_To_Targ_Float ( MTYPE_F8, v ) );
03653      TCON_ty(c) = ty;
03654      return c;
03655      
03656    default:
03657      ErrMsg ( EC_Inv_Mtype, Mtype_Name(ty), "Host_To_Targ_Float" );
03658      TCON_clear(c);
03659      TCON_ty(c) = MTYPE_F4;
03660      return c;
03661   }
03662 }
03663 
03664 TCON
03665 Host_To_Targ_Float_10 ( TYPE_ID ty, long double v )
03666 {
03667   TCON c;
03668 
03669   switch (ty) {
03670    case MTYPE_F10:
03671      TCON_clear(c);
03672      TCON_ty(c) = ty;
03673      TCON_R16(c) = v;
03674      return c;
03675 
03676    default:
03677      ErrMsg ( EC_Inv_Mtype, Mtype_Name(ty), "Host_To_Targ_Float_10" );
03678      TCON_clear(c);
03679      TCON_ty(c) = MTYPE_F4;
03680      return c;
03681   }
03682 }
03683 
03684 /* like Host_To_Targ_Float but avoids conversion from float to double */
03685 TCON
03686 Host_To_Targ_Float_4 ( TYPE_ID ty, float v )
03687 {
03688   TCON c;
03689 
03690   switch (ty) {
03691    case MTYPE_C4:
03692    case MTYPE_F4:
03693      TCON_clear(c);
03694      TCON_ty(c) = ty;
03695      Set_TCON_R4(c,v);
03696      return c;
03697 
03698    case MTYPE_C8:
03699    case MTYPE_F8:
03700      TCON_clear(c);
03701      TCON_ty(c) = ty;
03702      TCON_R8(c) = v;
03703      return c;
03704 
03705    case MTYPE_C10:
03706    case MTYPE_F10:
03707      TCON_clear(c);
03708      TCON_ty(c) = ty;
03709      TCON_R16(c) = v;
03710      return c;
03711 
03712    case MTYPE_CQ:
03713    case MTYPE_FQ:
03714      TCON_clear(c);
03715      c = Targ_Conv (MTYPE_FQ,
03716         Host_To_Targ_Float_4 ( MTYPE_F8, v ) );
03717      TCON_ty(c) = ty;
03718      return c;
03719      
03720    default:
03721      ErrMsg ( EC_Inv_Mtype, Mtype_Name(ty), "Host_To_Targ_Float_4" );
03722      TCON_clear(c);
03723      TCON_ty(c) = MTYPE_F4;
03724      return c;
03725   }
03726 }
03727 
03728 TCON
03729 Host_To_Targ_UV( TYPE_ID ty)
03730 {
03731   TCON c;
03732 
03733   TCON_clear(c);
03734   TCON_ty(c) = ty;
03735 
03736   switch (ty) {
03737    case MTYPE_F4:
03738      TCON_v1(c)= 0xfffa5a5a;
03739      break;
03740    case MTYPE_F8:
03741      TCON_v0(c)= 0xfffa5a5a;
03742      TCON_v1(c)= 0xfffa5a5a;
03743      break;
03744    case MTYPE_FQ:
03745      TCON_v0(c)= 0xfffa5a5a;
03746      TCON_v1(c)= 0xfffa5a5a;
03747      TCON_v2(c)= 0xfffa5a5a;
03748      TCON_v3(c)= 0xfffa5a5a;
03749      break;
03750    case MTYPE_C4:
03751      TCON_v1(c)= 0xfffa5a5a;
03752      TCON_iv1(c)= 0xfffa5a5a;
03753      break;
03754    case MTYPE_C8:
03755      TCON_v0(c)= 0xfffa5a5a;
03756      TCON_v1(c)= 0xfffa5a5a;
03757      TCON_iv0(c)= 0xfffa5a5a;
03758      TCON_iv1(c)= 0xfffa5a5a;
03759      break;
03760    case MTYPE_CQ:
03761      TCON_v0(c)= 0xfffa5a5a;
03762      TCON_v1(c)= 0xfffa5a5a;
03763      TCON_v2(c)= 0xfffa5a5a;
03764      TCON_v3(c)= 0xfffa5a5a;
03765      TCON_iv0(c)= 0xfffa5a5a;
03766      TCON_iv1(c)= 0xfffa5a5a;
03767      TCON_iv2(c)= 0xfffa5a5a;
03768      TCON_iv3(c)= 0xfffa5a5a;
03769      break;
03770      
03771    default:
03772      ErrMsg ( EC_Inv_Mtype, Mtype_Name(ty), "Host_To_Targ_UV" );
03773      TCON_clear(c);
03774      TCON_ty(c) = MTYPE_F4;
03775      return c;
03776   }
03777   return c;
03778 } /* Host_To_Targ_UV */
03779 
03780 /* Make complex TCON from two TCONs representing real and imaginary parts. */
03781 TCON
03782 Make_Complex ( TYPE_ID ctype, TCON real, TCON imag )
03783 {
03784   TCON c;
03785 
03786   TCON_clear(c);
03787   TCON_ty(c) = ctype;
03788   switch (ctype) {
03789   case MTYPE_C4:
03790      Set_TCON_R4(c, TCON_R4(real));
03791      Set_TCON_IR4(c, TCON_R4(imag));
03792      break;
03793 
03794   case MTYPE_C8:
03795      Set_TCON_R8(c, TCON_R8(real));
03796      Set_TCON_IR8(c, TCON_R8(imag));
03797      break;
03798      
03799   case MTYPE_C10:
03800   case MTYPE_CQ:
03801      Set_TCON_R16(c, TCON_R16(real));
03802      Set_TCON_IR16(c, TCON_R16(imag));
03803      break;
03804      
03805   default:
03806      ErrMsg ( EC_Inv_Mtype, Mtype_Name(ctype), "Make_Complex" );
03807      break;
03808   }
03809   return c;
03810 } /* Make_Complex */
03811 
03812 
03813 TCON
03814 Extract_Complex_Real(TCON complex)
03815 {
03816   TCON c;
03817   TCON_clear(c);
03818 
03819   switch (TCON_ty(complex)) {
03820   case MTYPE_C4:
03821      TCON_ty(c) = MTYPE_F4;
03822      Set_TCON_R4(c, TCON_R4(complex));
03823      return c;
03824 
03825   case MTYPE_C8:
03826      TCON_ty(c) = MTYPE_F8;
03827      Set_TCON_R8(c, TCON_R8(complex));
03828      return c;
03829      
03830   case MTYPE_C10:
03831      TCON_ty(c) = MTYPE_F10;
03832      Set_TCON_R16(c, TCON_R16(complex));
03833      return c;
03834      
03835   case MTYPE_CQ:
03836      TCON_ty(c) = MTYPE_FQ;
03837      Set_TCON_R16(c, TCON_R16(complex));
03838      return c;
03839      
03840   default:
03841      ErrMsg ( EC_Inv_Mtype, Mtype_Name(TCON_ty(complex)), "Extract_Complex_Real" );
03842      TCON_ty(c) = MTYPE_F4;
03843      return c;
03844   }
03845 }
03846 
03847 TCON
03848 Extract_Complex_Imag(TCON complex)
03849 {
03850   TCON c;
03851   TCON_clear(c);
03852 
03853   switch (TCON_ty(complex)) {
03854   case MTYPE_C4:
03855      TCON_ty(c) = MTYPE_F4;
03856      Set_TCON_R4(c, TCON_IR4(complex));
03857      return c;
03858 
03859   case MTYPE_C8:
03860      TCON_ty(c) = MTYPE_F8;
03861      Set_TCON_R8(c, TCON_IR8(complex));
03862      return c;
03863      
03864   case MTYPE_C10:
03865      TCON_ty(c) = MTYPE_F10;
03866      Set_TCON_R16(c, TCON_IR16(complex));
03867      return c;
03868 
03869   case MTYPE_CQ:
03870      TCON_ty(c) = MTYPE_FQ;
03871      Set_TCON_R16(c, TCON_IR16(complex));
03872      return c;
03873      
03874   default:
03875      ErrMsg ( EC_Inv_Mtype, Mtype_Name(TCON_ty(complex)), "Extract_Complex_Real" );
03876      TCON_ty(c) = MTYPE_F4;
03877      return c;
03878   }
03879 }
03880 
03881 TCON
03882 Extract_Quad_Hi(TCON v)
03883 {
03884   TCON c;
03885   TCON_clear(c);
03886 
03887   switch (TCON_ty(v)) {
03888   case MTYPE_FQ:
03889     {
03890       QUAD  quadTemp = R16_To_RQ(TCON_R16(v));
03891 
03892       TCON_ty(c) = MTYPE_F8;
03893       Set_TCON_R8(c, quadTemp.hi);
03894       return c;
03895     }
03896   /***************************************************
03897   TO BE DETERMINED
03898   case MTYPE_CQ:
03899     {
03900        quad quadTemp = R16_To_RQ(TCON_IR16(v));
03901 
03902        TCON_ty(c) = MTYPE_C8;
03903        Set_TCON_R16(c, TCON_IR16(complex));
03904        return c;
03905     }
03906   ***************************************************/
03907   default:
03908      ErrMsg ( EC_Inv_Mtype, Mtype_Name(TCON_ty(v)), "Extract_Quad_Hi" );
03909      TCON_ty(c) = MTYPE_F4;
03910      return c;
03911   }
03912 }
03913 
03914 TCON
03915 Extract_Quad_Lo(TCON v)
03916 {
03917   TCON c;
03918   TCON_clear(c);
03919 
03920   switch (TCON_ty(v)) {
03921   case MTYPE_FQ:
03922     {
03923       QUAD  quadTemp = R16_To_RQ(TCON_R16(v));
03924 
03925       TCON_ty(c) = MTYPE_F8;
03926       Set_TCON_R8(c, quadTemp.lo);
03927       return c;
03928     }
03929   /***************************************************
03930   TO BE DETERMINED
03931   case MTYPE_CQ:
03932     {
03933        quad quadTemp = R16_To_RQ(TCON_IR16(v));
03934 
03935        TCON_ty(c) = MTYPE_C8;
03936        Set_TCON_R16(c, TCON_IR16(complex));
03937        return c;
03938     }
03939   ***************************************************/
03940   default:
03941      ErrMsg ( EC_Inv_Mtype, Mtype_Name(TCON_ty(v)), "Extract_Quad_Lo" );
03942      TCON_ty(c) = MTYPE_F4;
03943      return c;
03944   }
03945 }
03946 
03947 TCON
03948 Host_To_Targ_Quad(QUAD_TYPE v)
03949 {
03950   static TCON c;
03951   
03952   TCON_ty(c) = MTYPE_FQ;
03953   TCON_R16(c) = v;
03954   return c;
03955 }
03956 
03957 TCON
03958 Host_To_Targ_Complex_Quad(QUAD_TYPE real, QUAD_TYPE imag)
03959 {
03960   static TCON c;
03961  
03962   TCON_ty(c) = MTYPE_CQ;
03963   TCON_R16(c) = real;
03964   TCON_IR16(c) = imag;
03965   return c;
03966 }
03967 
03968 
03969 double 
03970 Targ_To_Host_Float(TCON fvalue)
03971 { 
03972   INT16 ty = TCON_ty(fvalue);
03973 
03974   switch (ty) {
03975     case MTYPE_F4:
03976       return (double)TCON_R4(fvalue);
03977 
03978     case MTYPE_F8:
03979       return TCON_R8(fvalue);
03980 
03981     case MTYPE_F10:
03982   return (double)TCON_R16(fvalue);
03983 
03984     case MTYPE_FQ:
03985       return Targ_To_Host_Float(Targ_Conv(MTYPE_F8, fvalue));
03986 
03987     default:
03988       ErrMsg ( EC_Inv_Mtype, Mtype_Name(ty), "Targ_To_Host_Float" );
03989       return Targ_To_Host_Float(Targ_Conv(MTYPE_F8, fvalue));
03990   }
03991 } /* Targ_To_Host_Float */
03992 
03993 double 
03994 Targ_To_Host_ComplexReal(TCON fvalue)
03995 { 
03996   INT16 ty = TCON_ty(fvalue);
03997 
03998   switch (ty) {
03999     case MTYPE_C4:
04000       return (double)TCON_R4(fvalue);
04001 
04002     case MTYPE_C8:
04003       return TCON_R8(fvalue);
04004 
04005 #ifdef TARG_IA64
04006     case MTYPE_C10:
04007       return (double)TCON_R16(fvalue);
04008 #endif
04009       
04010     case MTYPE_CQ:
04011       return Targ_To_Host_Float(Targ_Conv(MTYPE_CQ, fvalue));
04012 
04013     default:
04014       ErrMsg ( EC_Inv_Mtype, Mtype_Name(ty), "Targ_To_Host_ComplexReal" );
04015       return Targ_To_Host_Float(Targ_Conv(MTYPE_C8, fvalue));
04016   }
04017 }
04018 
04019 double 
04020 Targ_To_Host_ComplexImag(TCON fvalue)
04021 { 
04022   INT16 ty = TCON_ty(fvalue);
04023 
04024   switch (ty) {
04025     case MTYPE_C4:
04026       return (double)TCON_IR4(fvalue);
04027 
04028     case MTYPE_C8:
04029       return TCON_IR8(fvalue);
04030 
04031 #ifdef TARG_IA64
04032     case MTYPE_C10:
04033       return (double)TCON_R16(fvalue);
04034 #endif
04035 
04036     case MTYPE_CQ:
04037       return Targ_To_Host_Float(Targ_Conv(MTYPE_C8, fvalue));
04038 
04039     default:
04040       ErrMsg ( EC_Inv_Mtype, Mtype_Name(ty), "Targ_To_Host_ComplexImag" );
04041       return Targ_To_Host_Float(Targ_Conv(MTYPE_C8, fvalue));
04042   }
04043 }
04044 
04045 QUAD_TYPE 
04046 Targ_To_Host_Quad(TCON fvalue)
04047 {
04048   INT16 ty = TCON_ty(fvalue);
04049 
04050   switch (ty) {
04051     case MTYPE_F4:
04052       return Targ_To_Host_Quad(Targ_Conv(MTYPE_FQ, fvalue));
04053 
04054     case MTYPE_F8:
04055       return Targ_To_Host_Quad(Targ_Conv(MTYPE_FQ, fvalue));
04056 
04057     case MTYPE_F10:
04058     case MTYPE_FQ:
04059       return TCON_R16(fvalue);
04060 
04061     default:
04062       ErrMsg ( EC_Inv_Mtype, Mtype_Name(ty), "Targ_To_Host_Quad" );
04063       return Targ_To_Host_Quad(Targ_Conv(MTYPE_FQ, fvalue));
04064   }
04065 } /* Targ_To_Host_Quad */
04066 
04067 INT
04068 fp_class_e(long double x)
04069 {
04070   return FP_QNAN;
04071 }
04072 
04073 INT
04074 fp_class_d( double x )
04075 {
04076   UINT64 ll, exp, mantissa;
04077   INT32 sign;
04078 
04079   ll = *(UINT64*)&x;
04080   exp = (ll >> DMANTWIDTH);
04081   sign = (exp >> DEXPWIDTH);
04082   exp &= 0x7ff;
04083   mantissa = (ll & (DSIGNMASK & DEXPMASK));
04084   if ( exp == 0x7ff ) {
04085     /* result is an infinity, or a NaN */
04086     if ( mantissa == 0 )
04087       return ( (sign == 0) ? FP_POS_INF : FP_NEG_INF );
04088     else if ( mantissa & ~DQNANBITMASK )
04089       return ( FP_QNAN );
04090     else
04091       return ( FP_SNAN );
04092   }
04093 
04094   if ( exp == 0 ) {
04095     if ( mantissa == 0 )
04096       return ( (sign == 0) ? FP_POS_ZERO : FP_NEG_ZERO );
04097     else
04098       return ( (sign == 0) ? FP_POS_DENORM : FP_NEG_DENORM );
04099   }
04100   else
04101     return ( (sign == 0) ? FP_POS_NORM : FP_NEG_NORM );
04102 }
04103 
04104 INT
04105 fp_class_f( float x )
04106 {
04107   UINT32 n, exp, mantissa;
04108   INT32 sign;
04109 
04110   n = *(UINT32 *)&x;
04111   exp = (n >> MANTWIDTH);
04112   sign = (exp >> EXPWIDTH);
04113   exp &= 0xff;
04114   mantissa = (n & (SIGNMASK & EXPMASK));
04115 
04116   if ( exp == 0xff ) {
04117     /* result is an infinity, or a NaN */
04118   if ( mantissa == 0 )
04119     return ( (sign == 0) ? FP_POS_INF : FP_NEG_INF );
04120   else if ( mantissa & ~QNANBITMASK )
04121     return ( FP_QNAN );
04122   else
04123     return ( FP_SNAN );
04124   }
04125 
04126   if ( exp == 0 ) {
04127     if ( mantissa == 0 )
04128       return ( (sign == 0) ? FP_POS_ZERO : FP_NEG_ZERO );
04129     else
04130       return ( (sign == 0) ? FP_POS_DENORM : FP_NEG_DENORM );
04131   }
04132   else
04133     return ( (sign == 0) ? FP_POS_NORM : FP_NEG_NORM );
04134 }
04135 
04136 INT32 
04137 Targ_fp_class(TCON fvalue)
04138 {
04139    INT16 ty = TCON_ty(fvalue);
04140 
04141    switch (ty) {
04142    case MTYPE_F4:
04143       return fp_class_f(TCON_R4(fvalue));
04144 
04145    case MTYPE_F8:
04146       return fp_class_d(TCON_R8(fvalue));
04147 
04148    case MTYPE_F10:
04149       return fp_class_e(TCON_R16(fvalue));
04150 
04151 #ifdef TARG_NEEDS_QUAD_OPS
04152    case MTYPE_FQ:
04153       return __c_fp_class_q(R16_To_RQ(TCON_R16(fvalue)));
04154 #endif
04155 
04156    default:
04157       ErrMsg ( EC_Inv_Mtype, Mtype_Name(ty), "Targ_fp_class" );
04158       return FP_QNAN;
04159    }
04160 } /* Targ_fp_class */
04161 
04162 TCON
04163 Host_To_Targ_Complex ( TYPE_ID ty, double real, double imag )
04164 {
04165   TCON c;
04166 
04167   TCON_clear(c);
04168   TCON_ty(c) = ty;
04169 
04170   switch (ty) {
04171 
04172    case MTYPE_C4:
04173      TCON_R4(c) = real;
04174      TCON_IR4(c) = imag;
04175      return c;
04176 
04177    case MTYPE_C8:
04178      TCON_R8(c) = real;
04179      TCON_IR8(c) = imag;
04180      return c;
04181 
04182    case MTYPE_C10:
04183      TCON_R16(c) = real;
04184      TCON_IR16(c) = imag;
04185      return c;
04186 
04187    default:
04188      ErrMsg ( EC_Inv_Mtype, Mtype_Name(ty), __func__ );
04189      TCON_ty(c) = MTYPE_C4;
04190      return c;
04191   }
04192 }
04193 
04194 TCON
04195 Host_To_Targ_Complex_10 ( TYPE_ID ty, long double real, long double imag )
04196 {
04197   TCON c;
04198 
04199   TCON_clear(c);
04200   TCON_ty(c) = ty;
04201 
04202   switch (ty) {
04203 
04204    case MTYPE_C4:
04205      TCON_R4(c) = real;
04206      TCON_IR4(c) = imag;
04207      return c;
04208 
04209    case MTYPE_C8:
04210      TCON_R8(c) = real;
04211      TCON_IR8(c) = imag;
04212      return c;
04213 
04214    case MTYPE_C10:
04215      TCON_R16(c) = real;
04216      TCON_IR16(c) = imag;
04217      return c;
04218 
04219    default:
04220      ErrMsg ( EC_Inv_Mtype, Mtype_Name(ty), __func__ );
04221      TCON_ty(c) = MTYPE_C4;
04222      return c;
04223   }
04224 }
04225 
04226 TCON
04227 Host_To_Targ_Complex_4 ( TYPE_ID ty, float real, float imag )
04228 {
04229   TCON c;
04230 
04231   TCON_clear(c);
04232   TCON_ty(c) = ty;
04233 
04234   switch (ty) {
04235    case MTYPE_C4:
04236      TCON_R4(c) = real;
04237      TCON_IR4(c) = imag;
04238      return c;
04239 
04240    case MTYPE_C8:
04241      TCON_R8(c) = real;
04242      TCON_IR8(c) = imag;
04243      return c;
04244 
04245    case MTYPE_C10:
04246      TCON_R16(c) = real;
04247      TCON_IR16(c) = imag;
04248      return c;
04249 
04250    default:
04251      ErrMsg ( EC_Inv_Mtype, Mtype_Name(ty), __func__ );
04252      TCON_ty(c) = MTYPE_C4;
04253      return c;
04254   }
04255 }
04256 
04257 
04258 TCON
04259 Host_To_Targ_String ( TYPE_ID ty, const char *v, UINT32 l )
04260 {
04261   static TCON c;
04262   BOOL add_null = FALSE;  /* whether to add a NULL in strtab */
04263   Is_True(ty==MTYPE_STRING,
04264           ("Bad type of const to Host_To_Targ_String: %s", Mtype_Name(ty)));
04265   TCON_clear(c);
04266   TCON_ty(c) = ty;
04267   /* for debugging purposes, we ensure that the tcon string is 
04268    * null-terminated; however, we keep the len as is, without the null. */
04269   if (l == 0 || v[l-1] != '\0')
04270   add_null = TRUE;
04271   /* use StrN in case a wide-string with non-terminating NULLs */
04272   TCON_cp(c) = Save_StrN(v, (add_null ? l+1 : l));
04273   if (add_null)
04274       Index_to_char_array (TCON_cp(c))[l] = '\0';
04275   TCON_len(c) = l;
04276   return (c);
04277 }
04278 
04279 char *
04280 Targ_String_Address ( TCON c )
04281 {
04282   Is_True(TCON_ty(c)==MTYPE_STRING,
04283           ("Bad type of const to Host_To_Targ_String: %s",
04284             Mtype_Name(TCON_ty(c))));
04285   return Index_to_char_array (TCON_cp(c));
04286 }
04287  
04288 mUINT32
04289 Targ_String_Length ( TCON c )
04290 {
04291   Is_True(TCON_ty(c)==MTYPE_STRING,
04292           ("Bad type of const to Host_To_Targ_String: %s",
04293             Mtype_Name(TCON_ty(c))));
04294   return ( TCON_len(c) );
04295 }
04296  
04297 
04298 static TCON Targ_Ipower(TCON base, UINT64 exp, BOOL neg_exp, BOOL *folded, TYPE_ID btype)
04299 {
04300    OPCODE mpy_op,div_op;
04301    TCON r;
04302 #ifdef TARG_NEEDS_QUAD_OPS
04303    INT err;
04304 #endif
04305    
04306    *folded = TRUE;
04307    TCON_clear(r);
04308    TCON_ty(r) = btype;
04309 
04310    switch (btype) {
04311     case MTYPE_I4:
04312       mpy_op = OPC_I4MPY;
04313       div_op = OPCODE_UNKNOWN;
04314       TCON_I4(r) = 1;
04315       break;
04316     case MTYPE_U4:
04317       mpy_op = OPC_U4MPY;
04318       div_op = OPCODE_UNKNOWN;
04319       TCON_U4(r) = 1;
04320       break;
04321     case MTYPE_I8:
04322       mpy_op = OPC_I8MPY;
04323       div_op = OPCODE_UNKNOWN;
04324       TCON_I8(r) = 1;
04325       break;
04326     case MTYPE_U8:
04327       mpy_op = OPC_U8MPY;
04328       div_op = OPCODE_UNKNOWN;
04329       TCON_U8(r) = 1;
04330       break;
04331     case MTYPE_F4:
04332       mpy_op = OPC_F4MPY;
04333       div_op = OPC_F4RECIP;
04334       TCON_R4(r) = 1.0;
04335       break;
04336     case MTYPE_F8:
04337       mpy_op = OPC_F8MPY;
04338       div_op = OPC_F8RECIP;
04339       TCON_R8(r) = 1.0;
04340       break;
04341     case MTYPE_F10:
04342       mpy_op = OPC_F10MPY;
04343       div_op = OPC_F10RECIP;
04344       TCON_R16(r) = 1.0;
04345       break;
04346 
04347 #ifdef TARG_NEEDS_QUAD_OPS
04348     case MTYPE_FQ:
04349       mpy_op = OPC_FQMPY;
04350       div_op = OPC_FQRECIP;
04351       TCON_R16(r) = RQ_To_R16(__c_q_ext(1.0,&err));
04352       break;
04353 #endif
04354     case MTYPE_C4:
04355       mpy_op = OPC_C4MPY;
04356       div_op = OPC_C4RECIP;
04357       TCON_R4(r) = 1.0;
04358       break;
04359     case MTYPE_C8:
04360       mpy_op = OPC_C8MPY;
04361       div_op = OPC_C8RECIP;
04362       TCON_R8(r) = 1.0;
04363       break;
04364     case MTYPE_C10:
04365       mpy_op = OPC_C10MPY;
04366       div_op = OPC_C10RECIP;
04367       TCON_R16(r) = 1.0;
04368       break;
04369 #ifdef TARG_NEEDS_QUAD_OPS
04370     case MTYPE_CQ:
04371       mpy_op = OPC_CQMPY;
04372       div_op = OPC_CQRECIP;
04373       TCON_R16(r) = RQ_To_R16(__c_q_ext(1.0,&err));
04374       break;
04375 #endif
04376    }
04377 
04378    /* At this point r contains 1, do the square and multiply loop */
04379    while (exp != 0) {
04380       if (exp & 1) {
04381    r = Targ_WhirlOp(mpy_op,r,base,NULL);
04382       }
04383       base = Targ_WhirlOp(mpy_op,base,base,NULL);
04384       exp >>= 1;
04385    }
04386 
04387    /* take reciprocal if negative denominator */
04388    if (neg_exp) {
04389       if (div_op) {
04390    r = Targ_WhirlOp(div_op,r,r,folded);
04391       } else {
04392    /* Integer reciprocal is easy. If r is not 0, 1, or -1,
04393       return 0. If it's 0, give up */
04394    switch (TCON_ty(base)) {
04395     case MTYPE_I4:
04396       if (TCON_I4(r) == 0) {
04397          *folded = FALSE;
04398       } else if (TCON_I4(r) != 1 && TCON_I4(r) != -1) {
04399          TCON_I4(r) = 0;
04400       }
04401       break;
04402     case MTYPE_U4:
04403       if (TCON_U4(r) == 0) {
04404          *folded = FALSE;
04405       } else if (TCON_U4(r) != 1) {
04406          TCON_U4(r) = 0;
04407       }
04408       break;
04409     case MTYPE_I8:
04410       if (TCON_I8(r) == 0) {
04411          *folded = FALSE;
04412       } else if (TCON_I8(r) != 1 && TCON_I8(r) != -1) {
04413          TCON_I8(r) = 0;
04414       }
04415       break;
04416     case MTYPE_U8:
04417       if (TCON_U8(r) == 0) {
04418          *folded = FALSE;
04419       } else if (TCON_U8(r) != 1) {
04420          TCON_U8(r) = 0;
04421       }
04422       break;
04423    }
04424       }
04425    }
04426    return (r);
04427 }
04428 
04429 
04430 /* General exponentiation routine. If nothing is done, return
04431    FALSE in folded */
04432 
04433 
04434 static TCON Targ_Power(TCON base, TCON exp, BOOL *folded, TYPE_ID btype) 
04435 {
04436    UINT64 int_exp;
04437    BOOL   neg_exp;
04438    TCON r;
04439    
04440 
04441    TCON_clear (r);
04442 
04443    /* Check for integer exponent */
04444    if (TCON_ty(exp) == MTYPE_U8) {
04445       return (Targ_Ipower(base, TCON_U8(exp), FALSE, folded, btype));
04446    } else if (TCON_ty(exp) == MTYPE_U4) {
04447       return (Targ_Ipower(base, (UINT64) TCON_U4(exp), FALSE, folded, btype));
04448    } else if (TCON_ty(exp) == MTYPE_I4) {
04449       int_exp = TCON_I4(exp);
04450       neg_exp = FALSE;
04451       if ((INT64) int_exp < 0) {
04452    neg_exp = TRUE;
04453    int_exp = -((INT64) int_exp);
04454       }
04455       return (Targ_Ipower(base,int_exp,neg_exp,folded,btype));
04456 
04457    } else if (TCON_ty(exp) == MTYPE_I8) {
04458       int_exp = TCON_I8(exp);
04459       neg_exp = FALSE;
04460 
04461       if (int_exp == 0x8000000000000000LL) {
04462    neg_exp = TRUE;
04463       } else if ((INT64) int_exp < 0) {
04464    int_exp = -((INT64)int_exp);
04465    neg_exp = TRUE;
04466       }
04467       return (Targ_Ipower(base,int_exp,neg_exp,folded,btype));
04468    }
04469 
04470    /* Check for the same type */
04471    if (TCON_ty(base) != TCON_ty(exp)) {
04472       if (folded) *folded = FALSE;
04473       return (r);
04474    }
04475 
04476    /* Do the floating-point types */
04477 
04478    switch (TCON_ty(base)) {
04479     case MTYPE_F4:
04480       TCON_ty(r) = MTYPE_F4;
04481       TCON_R4(r) = pow ((double) TCON_R4(base), (double) TCON_R4(exp));
04482       break;
04483 
04484     case MTYPE_F8:
04485       TCON_ty(r) = MTYPE_F8;
04486       TCON_R8(r) = pow (TCON_R8(base),TCON_R8(exp));
04487       break;
04488 
04489     default:
04490       /* Not done yet */
04491       if (folded) *folded = FALSE;
04492       break;
04493    }
04494 
04495    return (r);
04496 }
04497 
04498 #ifndef MONGOOSE_BE
04499 TCON
04500 Targ_Pow ( TCON a, TCON b )
04501 /* NOTE: No one invokes this function !! */
04502 
04503 {
04504   INT32 va, vb, r;
04505 
04506   va = TCON_v0(a);
04507   vb = TCON_v0(b);
04508   if (va == 0)
04509     r = 0;
04510   else if (va == 1)
04511     r = 1;
04512   else if (va == -1) {
04513     if (vb < 0) vb = -vb;
04514     r = (vb % 2) ? -1 : 1;
04515   } else if (vb == 0)
04516     r = 1;
04517   else if (vb < 0) /* va > 1 or va < -1. vb < 0. => 1/va**vb = 0 */
04518     r = 0;
04519   else {
04520     if (vb >= 63) {
04521 /*      ErrMsg ( EC_Exp_Oflow, va, vb );*/
04522       r = 0;
04523     } else {
04524       r = 1;
04525       while (vb--) r *= va;
04526     }
04527   }
04528   TCON_v0(a) = r;
04529   return a;
04530 } /* Targ_Pow */
04531 #endif /* MONGOOSE_BE */
04532 
04533 /* ====================================================================
04534  *
04535  * Targ_Append_To_Dbuf
04536  *
04537  * Append the given character to the given string, returning an updated
04538  * pointer to the string.  If the character is "special", use the C
04539  * format for it, e.g. "\n" for newline, "\003" for ^C, etc.
04540  *
04541  * ====================================================================
04542  */
04543 
04544 char *
04545 Targ_Append_To_Dbuf (char *str, char ch)
04546 {
04547   char ch1;
04548   if ( ch >= ' ' && ch <= '~' && ch != '\\' ) {
04549     *str++ = ch;
04550   } else {
04551     ch1 = 0;
04552     switch ( ch ) {
04553   case '\n':  ch1 = 'n'; break;
04554   case '\t':  ch1 = 't'; break;
04555   case '\b':  ch1 = 'b'; break;
04556   case '\r':  ch1 = 'r'; break;
04557   case '\f':  ch1 = 'f'; break;
04558   case '\v':  ch1 = 'v'; break;
04559   case '\?':  ch1 = '?'; break;
04560   case '\\':  ch1 = '\\'; break;
04561     }
04562     *str++ = '\\';
04563     if (ch1) 
04564         *str++ = ch1;
04565     else {
04566         sprintf(str, "%03o", ch & 0xff);
04567         str += 3;
04568     }
04569   }
04570   return str;
04571 } /* Targ_Append_To_Dbuf */
04572 
04573 #define DUMP_STR 1
04574 #ifdef DUMP_STR
04575 #define APPEND_TO_DBUF(a,b) a = Targ_Append_To_Dbuf(a,b)
04576 #else /* DUMP_STR */
04577 #define APPEND_TO_DBUF(a,b) 
04578 #endif /* DUMP_STR */
04579 
04580 #ifndef MONGOOSE_BE
04581 /* ====================================================================
04582  *
04583  * Targ_Format_String
04584  *
04585  * Format the given string as a printable string, by replacing special
04586  * characters by the C source codes, e.g. "\n" for newline, "\003" for
04587  * '^C', etc.  The caller passes the string to be formatted (s), its
04588  * length (slen, zero implying NULL termination), the string to format
04589  * it into (buf), a maximum length (lmax), a maximum line length (line,
04590  * may be 0 for no maximum), and a string to insert in the buffer
04591  * between lines (divider).
04592  *
04593  * If lmax may be exceeded, the source string is truncated, and the
04594  * buffer is terminated with an * ellipsis (...).  If line is non-zero,
04595  * the formatted string has "divider" inserted between segments of at
04596  * most line characters; "divider" will typically consist of a
04597  * terminating double quote, a newline, possibly a tab, and an opening
04598  * double quote.
04599  *
04600  * Inserted dividers do count against the maximum length, but not
04601  * against the line length.  The returned string is NULL-terminated,
04602  * and the terminating NULL counts against the maximum length.
04603  *
04604  * The return value indicates whether the full string was formatted.
04605  *
04606  * NOTE:  No attempt has been made to be efficient.
04607  *
04608  * ====================================================================
04609  */
04610 
04611 BOOL
04612 Targ_Format_String (
04613   char  *s, /* String to format, */
04614   INT32 slen, /* ... of this length, */
04615   char  *buf, /* ... into this buffer, */
04616   INT32 blen, /* ... with at most this many characters, */
04617   INT32 line, /* ... with lines at most this long (0 = no limit), */
04618   char  *divider )  /* ... divided by this string. */
04619 {
04620   INT32 len=0;  /* Actual formatted length */
04621   INT32 llen=0; /* Actual formatted line length */
04622   INT32 dlen = divider ? strlen(divider) : 0;
04623   char cbuf[5]; /* Buffer for a character */
04624   INT16 clen; /* Length of character in cbuf */
04625   INT32 i;
04626 
04627   /* Adjust input parameters: */
04628   if ( slen == 0 ) slen = strlen(s);
04629   if ( line == 0 || divider == NULL ) line = blen;
04630 
04631   for ( i=0; i<slen; i++ ) {
04632 
04633     /* Format the character.  Note that the maximum value of clen, for
04634      * a special character formatted \xxx, is 4:
04635      */
04636     clen = Targ_Append_To_Dbuf ( cbuf, s[i] ) - cbuf;
04637     cbuf[clen] = 0;
04638 
04639     /* Make sure there's room in this line for the string --
04640      * we are conservative:
04641      */
04642     if ( llen > line-clen ) {
04643       /* If there's no room in buffer, ignore line length limit: */
04644       if ( len < blen-dlen-clen-1 ) {
04645   (void) strcpy ( buf, divider );
04646   buf += dlen;
04647   len += dlen;
04648   llen = 0;
04649       }
04650     }
04651 
04652     /* Is there room in the buffer for it? */
04653     if ( len+clen < blen ) {
04654       /* Yes: */
04655       (void) strcpy ( buf, cbuf );
04656       buf += clen;
04657       len += clen;
04658       llen += clen;
04659     } else {
04660       /* No:  insert ellipsis and quit: */
04661       if ( blen - len < 4 ) buf -= (len+4)-blen;
04662       (void) strcpy ( buf, "..." );
04663       return FALSE;
04664     }
04665   }
04666 
04667   /* We managed to format everything.  Note that copying the last
04668    * character always set terminating NULL.
04669    */
04670   return TRUE;
04671 } /* Targ_Format_String */
04672 
04673 
04674 
04675 #ifdef HAS_TCON_TO_STR
04676 /*----------------------------------------------------------------------
04677  * Put value of v in *buf in a host independent way.  buf will only
04678  * be accessed as char*.  The byte ordering within buf may be
04679  * 'implementation defined', but it must give the same results for the
04680  * same compiler on different hosts.
04681  *
04682  * TODO Josie/92: Integrate changes
04683  *--------------------------------------------------------------------*/
04684 char *
04685 Tcon_To_Str(buf, v)
04686   TCON v;
04687   char *buf;
04688 {
04689   INT *ip = (INT *) buf; /*TODO: or should this be INT64 ? */
04690   float *fp = (float *) buf;
04691   double *dp = (double *) buf;
04692   switch (TCON_ty(v)) {
04693     case MTYPE_B:
04694     case MTYPE_I1: /* may want to change for [IL][12] */
04695     case MTYPE_I2:
04696     case MTYPE_I4:
04697     case MTYPE_U1:
04698     case MTYPE_U2:
04699     case MTYPE_U4:
04700       /* if host and target byte order are different, we might want to do 
04701    something here */
04702       *ip = TCON_v0(v);
04703       break;
04704     case MTYPE_I8:
04705     case MTYPE_U8:
04706       /* if host and target byte order are different, we might want to do 
04707    something here */
04708       *ip = TCON_I8(v);
04709       break;
04710     case MTYPE_F4:
04711       /* user is attempting to look into individual bytes of floating constant 
04712    He better know the floating point format. Compilers responsibility
04713    is only to do the conversion in a host independent way, i.e., same
04714    source must give same object on whatever machine the compiler 
04715    is hosted */
04716       *fp = TCON_R4(v);
04717       break;
04718     case MTYPE_F8:
04719       *dp = TCON_R8(v);
04720       break;
04721     default:
04722       ErrMsg ( EC_Inv_Mtype, Mtype_Name(TCON_ty(v)), "Tcon_To_Str" );
04723   }
04724   return buf;
04725 } /* Tcon_To_Str */
04726 
04727 
04728 /*----------------------------------------------------------------------
04729  *  reverse of above. Used where constants have been specified in
04730  *  hex, binary, holleriths etc.
04731  *--------------------------------------------------------------------*/
04732 
04733 /*
04734  * Throughout this routine, if Same_Byte_Sex, then perform no
04735  * transformation on data string, otherwise perform byte-sex-change on
04736  * data.  We always have to copy to a local buffer in case the argument
04737  * buffer is not aligned properly.
04738  */
04739 TCON
04740 Str_To_Tcon(TYPE_ID ty, char *buf)
04741 {
04742   union {
04743     double d_align;   /* for alignment and size restrictions */
04744     char   buf[2*sizeof(double)];
04745   } local_buf;
04746   char *tbuf = (char *)&local_buf;
04747   TCON c;
04748   
04749   TCON_ty(c) = ty;
04750 
04751   switch (ty) {
04752     case MTYPE_I1:
04753     case MTYPE_U1: /* We want to sign-extend here; we'll truncate later */
04754       TCON_v0(c) = *buf;
04755       TCON_v1(c) = 0;
04756       break;
04757     case MTYPE_I2:
04758     case MTYPE_U2: /* We want to sign-extend here; we'll truncate later */
04759       if (Same_Byte_Sex) {
04760   tbuf[0] = buf[0];
04761   tbuf[1] = buf[1];
04762       } else {
04763   tbuf[0] = buf[1];
04764   tbuf[1] = buf[0];
04765       }
04766       TCON_v0(c) = *((mINT16 *)tbuf);
04767       TCON_v1(c) = 0;
04768       break;
04769     case MTYPE_I4:
04770     case MTYPE_U4:
04771       /* if host and target byte order are different, we might want to do 
04772    something here */
04773       if (Same_Byte_Sex) {
04774   tbuf[0] = buf[0];
04775   tbuf[1] = buf[1];
04776   tbuf[2] = buf[2];
04777   tbuf[3] = buf[3];
04778       } else {
04779   tbuf[0] = buf[3];
04780   tbuf[1] = buf[2];
04781   tbuf[2] = buf[1];
04782   tbuf[3] = buf[0];
04783       }
04784       TCON_v0(c) = *((INT32 *)tbuf);
04785       TCON_v1(c) = 0;
04786       break;
04787     case MTYPE_I8:
04788     case MTYPE_U8:
04789       /* if host and target byte order are different, we might want to do 
04790    something here */
04791       if (Same_Byte_Sex) {
04792   tbuf[0] = buf[0];
04793   tbuf[1] = buf[1];
04794   tbuf[2] = buf[2];
04795   tbuf[3] = buf[3];
04796   tbuf[4] = buf[4];
04797   tbuf[5] = buf[5];
04798   tbuf[6] = buf[6];
04799   tbuf[7] = buf[7];
04800   TCON_I8(c) = *((INT64 *)tbuf);
04801       } else {
04802   /* 
04803    * We must be very careful about which word gets which set of 4 
04804    * bytes here.  To be totally correct, buf[0] must go into the 
04805    * byte referenced by (char *)(TCON_I8(c)).  That would be the 
04806    * first word here, normally (ie, TCON_v0(c)).  However, since 
04807    * the current code is written to use the host's representation 
04808    * as the internal representation, there is a kludge in 
04809    * Emit_Const above which always swaps words when dumping to the 
04810    * output file.  As such, we swap the words here, so that the 
04811    * later swap will do the right thing.  Blech, kludge upon kludge.
04812    */
04813   tbuf[0] = buf[7];
04814   tbuf[1] = buf[6];
04815   tbuf[2] = buf[5];
04816   tbuf[3] = buf[4];
04817   TCON_v0(c) = *((INT *)tbuf);
04818   tbuf[0] = buf[3];
04819   tbuf[1] = buf[2];
04820   tbuf[2] = buf[1];
04821   tbuf[3] = buf[0];
04822   TCON_v1(c) = *((INT *)tbuf);
04823       }
04824       break;
04825     case MTYPE_F4:
04826       /* User is trying to give floating constant in hollerith, etc.
04827    He needs to know the floating point format.  On the other hand,
04828    he may be doing hollerith/character init of a variable which will
04829    be printed out as character data, in which case the user doesn't
04830    care what the format is.  Either way, the compiler's responsibility
04831    is only to do the conversion in a host independent way, i.e., same
04832    source must give same object on whatever machine the compiler 
04833    is hosted.
04834        */
04835       if (Same_Byte_Sex) {
04836   tbuf[0] = buf[0];
04837   tbuf[1] = buf[1];
04838   tbuf[2] = buf[2];
04839   tbuf[3] = buf[3];
04840       } else {
04841   tbuf[0] = buf[3];
04842   tbuf[1] = buf[2];
04843   tbuf[2] = buf[1];
04844   tbuf[3] = buf[0];
04845       }
04846       Set_TCON_R4 ( c, *((float *)tbuf) );
04847       TCON_v1(c) = 0;
04848       break;
04849 
04850     case MTYPE_F8:
04851       if (Same_Byte_Sex) {
04852   tbuf[0] = buf[0];
04853   tbuf[1] = buf[1];
04854   tbuf[2] = buf[2];
04855   tbuf[3] = buf[3];
04856   tbuf[4] = buf[4];
04857   tbuf[5] = buf[5];
04858   tbuf[6] = buf[6];
04859   tbuf[7] = buf[7];
04860   TCON_R8(c) = *((double *)tbuf);
04861       } else {
04862   /* 
04863    * We must be very careful about which word gets which set of 4 
04864    * bytes here.  To be totally correct, buf[0] must go into the 
04865    * byte referenced by (char *)(TCON_R8(c)).  That would be the 
04866    * first word here, normally (ie, TCON_v0(c)).  However, since 
04867    * the current code is written to use the host's representation 
04868    * as the internal representation, there is a kludge in 
04869    * Emit_Const above which always swaps words when dumping to the 
04870    * output file.  As such, we swap the words here, so that the 
04871    * later swap will do the right thing.  Blech, kludge upon kludge.
04872    */
04873   tbuf[0] = buf[7];
04874   tbuf[1] = buf[6];
04875   tbuf[2] = buf[5];
04876   tbuf[3] = buf[4];
04877   TCON_v0(c) = *((INT *)tbuf);
04878   tbuf[0] = buf[3];
04879   tbuf[1] = buf[2];
04880   tbuf[2] = buf[1];
04881   tbuf[3] = buf[0];
04882   TCON_v1(c) = *((INT *)tbuf);
04883       }
04884       break;
04885 
04886     default:
04887       ErrMsg ( EC_Inv_Mtype, Mtype_Name(ty), "Str_To_Tcon" );
04888   }
04889   return c;
04890 } /* Str_To_Tcon */
04891 
04892 #if 0 /*foo*/
04893 /* 
04894  * Bit_Str_To_Tcon
04895  * 
04896  * This routine is passed a sequence of bytes in buf[0], buf[1], ... 
04897  * which have the following semantics:  the byte in buf[0] is the least 
04898  * significant byte; the byte in buf[1] is the next least significant 
04899  * byte; etc until we run out of bytes for an object of be_type "ty".  
04900  * We must make a TCON which preserves the byte ordering regardless of 
04901  * target endianness.  Hence if the user does:
04902  *       i = '00001001'x
04903  * i had better get the value 4097.
04904  * It is the callers responsibility to provide us with "n" bytes of 
04905  * valid "buf" if the betype corresponding to "ty" requires "n" bytes 
04906  * of target representation.  In other words, MTYPE_I1 only requires 
04907  * that buf[0] be valid, but MTYPE_F8 requires that buf[0] through 
04908  * buf[7] be valid.  The caller must do any zero padding in buf as 
04909  * required so that buf[0] is the LSByte of the constant.
04910  * TODO:  is MTYPE_I1, buf[0] == 0xff supposed to be 255 or -1?
04911  *        Targ_To_Host doesn't care what we do, does anybody else?
04912  */
04913 
04914 TCON
04915 Bit_Str_To_Tcon ( TYPE_ID ty, char *arg_buf )
04916 {
04917   static TCON c;
04918   unsigned char *buf;
04919   UINT temp;
04920   
04921   buf = (unsigned char *)arg_buf; /* zero-extend our arg bytes */
04922   TCON_ty(c) = ty;
04923 
04924   switch (ty) {
04925     case MTYPE_I1:
04926     case MTYPE_U1: /* We want to sign-extend here; we'll truncate later */
04927       TCON_v0(c) = buf[0];
04928       TCON_v1(c) = 0;
04929       break;
04930 
04931     case MTYPE_I2:
04932     case MTYPE_U2: /* We want to sign-extend here; we'll truncate later */
04933       TCON_v0(c) = (buf[1] << 8) | buf[0];
04934       TCON_v1(c) = 0;
04935       break;
04936 
04937     case MTYPE_I4:
04938     case MTYPE_U4:
04939       TCON_v0(c) = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
04940       TCON_v1(c) = 0;
04941       break;
04942 
04943     case MTYPE_F4:
04944       /* user is trying to give floating constant in binary, octal, hex,
04945        * etc.  He had better know the floating point format.
04946        */
04947       temp = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
04948       Set_TCON_R4(c, *((float *)&temp));
04949       TCON_v1(c) = 0;
04950       break;
04951 
04952     case MTYPE_F8:
04953       /* We must be careful about which word gets which set of 4 bytes
04954        * here.  buf[0] must go into the most significant byte of
04955        * TCON_R8.  Since the current code is written to use the host's
04956        * representation as the internal representation, we must make
04957        * sure we put it in the proper place depending on the host's
04958        * endianness.
04959        */
04960 #if HOST_IS_BIG_ENDIAN
04961       TCON_v1(c) = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
04962       TCON_v0(c) = (buf[7] << 24) | (buf[6] << 16) | (buf[5] << 8) | buf[4];
04963 #else
04964       TCON_v0(c) = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
04965       TCON_v1(c) = (buf[7] << 24) | (buf[6] << 16) | (buf[5] << 8) | buf[4];
04966 #endif
04967       break;
04968 
04969     case MTYPE_FQ:
04970       /* We must be careful about which word gets which set of 4 bytes
04971        * here.  buf[0] must go into the most significant byte of
04972        * TCON_R8.  Since the current code is written to use the host's
04973        * representation as the internal representation, we must make
04974        * sure we put it in the proper place depending on the host's
04975        * endianness.
04976        */
04977 #if HOST_IS_BIG_ENDIAN
04978       TCON_v3(c) = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
04979       TCON_v2(c) = (buf[7] << 24) | (buf[6] << 16) | (buf[5] << 8) | buf[4];
04980       TCON_v1(c) = (buf[11] << 24) | (buf[10] << 16) | (buf[9] << 8) | buf[8];
04981       TCON_v0(c) = (buf[15] << 24) | (buf[14] << 16) | (buf[13] << 8) | buf[12];
04982 #else
04983       TCON_v0(c) = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
04984       TCON_v1(c) = (buf[7] << 24) | (buf[6] << 16) | (buf[5] << 8) | buf[4];
04985       TCON_v2(c) = (buf[11] << 24) | (buf[10] << 16) | (buf[9] << 8) | buf[8];
04986       TCON_v3(c) = (buf[15] << 24) | (buf[14] << 16) | (buf[13] << 8) | buf[12];
04987 #endif
04988       break;
04989 
04990     default:
04991       ErrMsg ( EC_Inv_Mtype, Mtype_Name(ty), "Bit_Str_To_Tcon" );
04992   }
04993   return c;
04994 } /* Bit_Str_To_Tcon */
04995 #endif /*foo*/
04996 
04997 #endif /* HAS_TCON_TO_STR */
04998 
04999 #endif /* MONGOOSE_BE */
05000 
05001 /* ====================================================================
05002  *
05003  * Targ_Is_Integral
05004  *
05005  * Determine whether a TCON represents an integral value, and if so
05006  * return its value.
05007  *
05008  * ====================================================================
05009  */
05010 
05011 BOOL
05012 Targ_Is_Integral ( TCON tc, INT64 *iv )
05013 {
05014   switch (TCON_ty(tc)) {
05015     case MTYPE_B:
05016     case MTYPE_I1:
05017     case MTYPE_I2:
05018     case MTYPE_I4:
05019       *iv = TCON_v0(tc);
05020       return TRUE;
05021 
05022     case MTYPE_U1:
05023     case MTYPE_U2:
05024     case MTYPE_U4:
05025       *iv = TCON_u0(tc);
05026       return TRUE;
05027 
05028     case MTYPE_I8:
05029     case MTYPE_U8:
05030       *iv = TCON_I8(tc);
05031       return TRUE;
05032 
05033     case MTYPE_F4:
05034       {
05035   INT32 k = (INT32)TCON_R4(tc);
05036   float s = k;
05037   if (s == TCON_R4(tc)) {
05038     *iv = k;
05039     return TRUE;
05040   }
05041       }
05042       return FALSE;
05043 
05044     case MTYPE_F8:
05045       {
05046   INT64 k = (INT64)TCON_R8(tc);
05047   double d = k;
05048   if (d == TCON_R8(tc)) {
05049     *iv = k;
05050     return TRUE;
05051   }
05052       }
05053       return FALSE;
05054 
05055     case MTYPE_F10:
05056       {
05057   QUAD_TYPE ld = floorl(TCON_R16(tc));
05058   if (ld == TCON_R16(tc)) {
05059     INT64 ll = (INT64)ld;
05060     if ((QUAD_TYPE)ll == ld) {
05061       *iv = ll;
05062       return TRUE;
05063     }
05064   }
05065   return FALSE;
05066       }
05067 
05068 #ifdef TARG_NEEDS_QUAD_OPS
05069     case MTYPE_FQ:
05070       {
05071   QUAD  q;
05072   INT32 err;
05073   INT32 k = __c_ji_qint(R16_To_RQ(TCON_R16(tc)), &err);
05074   if (err) return FALSE;
05075   q = __c_q_flotj(k, &err);
05076   if (err) return FALSE;
05077   if (__c_q_eq(q, R16_To_RQ(TCON_R16(tc)), &err)) {
05078           if (err) return FALSE;
05079     *iv = k;
05080     return TRUE;
05081   }
05082       }
05083       return FALSE;
05084 #endif
05085 
05086     /* TODO : fix for mongoose */
05087     case MTYPE_C4:
05088     case MTYPE_C8:
05089     case MTYPE_C10:
05090     case MTYPE_CQ:
05091       return FALSE;
05092 
05093     case MTYPE_STR:
05094       return FALSE;
05095 
05096     default:
05097       ErrMsg ( EC_Inv_Mtype, Mtype_Name(TCON_ty(tc)),
05098          "Targ_Is_Integral" );
05099   }
05100   return FALSE;
05101 } /* Targ_Is_Integral */
05102 
05103 #ifdef OLDCODE
05104 #ifdef FRONT_END
05105 
05106 /**********************************************************************/
05107 /* Coerce the input parameter to an integer constant, if the          */
05108 /* conversion can be done without loss of significance                */
05109 /**********************************************************************/ 
05110 WN *
05111 Coerce_To_Integer(subtree)
05112   WN *subtree;
05113 {
05114   TCON  operand, truncated, converted;
05115   WN   *coerced_subtree;
05116   INT32 err;
05117 
05118   coerced_subtree = subtree;
05119   truncated = MTYPE_size_min(TY_btype(The_Tree_Type(subtree))) <= 32 ?
05120       Zero_I4_Tcon : Zero_I8_Tcon;
05121 
05122   if (Is_Const(subtree, &operand)) {
05123     switch (TCON_ty(operand)) {
05124       case MTYPE_B:
05125       case MTYPE_I1:
05126       case MTYPE_I2: 
05127       case MTYPE_I4:
05128       case MTYPE_I8:
05129       case MTYPE_U1:
05130       case MTYPE_U2: 
05131       case MTYPE_U4:
05132       case MTYPE_U8:
05133         break;
05134 
05135       case MTYPE_F4:
05136         TCON_v0(truncated) = TCON_R4(operand);
05137         Set_TCON_R4 ( converted, TCON_v0(truncated) );
05138         if (TCON_R4(converted) == TCON_R4(operand)) {
05139           TCON_ty(truncated) = MTYPE_I4;
05140           coerced_subtree = Make_Const(truncated);
05141         }
05142         break;
05143   
05144       case MTYPE_F8:
05145         TCON_v0(truncated) = TCON_R8(operand);
05146         TCON_R8(converted) = TCON_v0(truncated);        
05147         if (TCON_R8(converted) == TCON_R8(operand)) {
05148           TCON_ty(truncated) = MTYPE_I4;
05149           coerced_subtree = Make_Const(truncated);
05150         }
05151         break;
05152  
05153       case MTYPE_F10:
05154         TCON_v0(truncated) = TCON_R16(operand);
05155         TCON_R16(converted) = TCON_v0(truncated);
05156         if (TCON_R16(converted) == TCON_R16(operand)) {
05157           TCON_ty(truncated) = MTYPE_I4;
05158           coerced_subtree = Make_Const(truncated);
05159         }
05160         break;
05161 
05162 #ifdef TARG_NEEDS_QUAD_OPS
05163       case MTYPE_FQ:
05164         TCON_v0(truncated) = __c_ji_qint(R16_To_RQ(TCON_R16(operand)), &err);
05165         TCON_R16(converted) = RQ_To_R16(__c_q_flotj(TCON_v0(truncated), &err));
05166         if (__c_q_eq(R16_To_RQ(TCON_R16(converted)), 
05167          R16_To_RQ(TCON_R16(operand)),
05168          &err)) {
05169           TCON_ty(truncated) = MTYPE_I4;
05170           coerced_subtree = Make_Const(truncated);
05171         }
05172         break;
05173 #endif
05174 
05175       default:
05176   ErrMsg ( EC_Inv_Mtype, Mtype_Name(TCON_ty(operand)),
05177      "Coerce_To_Integer" );
05178         break;
05179      }
05180   }
05181   return coerced_subtree;
05182 } /* Coerce_To_Integer */
05183 #endif
05184 #endif /* OLDCODE */
05185 
05186 /*----------------------------------------------------------------------------
05187  * return TRUE if the target representation of this TCON is has all zeros
05188  *--------------------------------------------------------------------------*/
05189 
05190 BOOL Targ_Is_Zero ( TCON t )
05191 {
05192   switch (TCON_ty(t)) {
05193     case MTYPE_B:
05194     case MTYPE_I1:
05195     case MTYPE_I2:
05196     case MTYPE_I4:
05197     case MTYPE_U1:
05198     case MTYPE_U2:
05199     case MTYPE_U4:
05200        return TCON_v0(t) == 0;
05201     case MTYPE_F4:
05202       /* make sure is not -0.0 (sign-bit set);
05203        * -0.0 will == 0.0, so add check for sign bit. */
05204       return (TCON_R4(t) == 0.0 && TCON_v0(t) == 0);
05205     case MTYPE_I8:
05206     case MTYPE_U8:
05207       return (TCON_v0(t)|TCON_v1(t)) == 0;
05208     case MTYPE_F8:
05209       /* make sure is not -0.0 (sign-bit set);
05210        * -0.0 will == 0.0, so add check for sign bit. */
05211       return (TCON_R8(t) == 0.0
05212   && (TCON_v0(t)|TCON_v1(t)) == 0);
05213     case MTYPE_F10:
05214       /* make sure is not -0.0 (sign-bit set);
05215        * -0.0 will == 0.0, so add check for sign bit. */
05216       return (TCON_R16(t) == 0.0 &&
05217   (TCON_v0(t)|TCON_v1(t)|TCON_v2(t)|TCON_v3(t)) == 0);
05218 
05219 #ifdef TARG_NEEDS_QUAD_OPS
05220     case MTYPE_FQ:
05221       {
05222   INT32 dummy_err;
05223   /* return (TCON_v0(t)|TCON_v1(t)|TCON_v2(t)|TCON_v3(t)) == 0; */
05224   return (__c_q_eq(R16_To_RQ(TCON_R16(t)), 
05225        __c_q_extd(0.0, &dummy_err), 
05226        &dummy_err));
05227       }
05228 #endif
05229 
05230     /* TODO : fix for mongoose */
05231     case MTYPE_C4:
05232     case MTYPE_C8:
05233     case MTYPE_C10:
05234     case MTYPE_CQ:
05235     case MTYPE_STR:
05236       return FALSE;
05237 
05238     default:
05239       ErrMsg ( EC_Inv_Mtype, Mtype_Name(TCON_ty(t)), "Targ_Is_Zero" );
05240   }
05241   return FALSE;
05242 } /* Targ_Is_Zero */
05243 
05244 /* ====================================================================
05245  *
05246  * Targ_Is_Power_Of_Two
05247  *
05248  * Determine whether the TCON represents a power of two.
05249  *
05250  * ====================================================================
05251  */
05252 
05253 BOOL
05254 Targ_Is_Power_Of_Two ( TCON t )
05255 {
05256    INT64 cval;
05257    INT32 exponent, mant;
05258 
05259    if ( Targ_Is_Integral ( t, &cval ) ) {
05260       if ( cval == 0 ) return FALSE;
05261       if ( cval == ( cval & ~(cval-1) ) ) return TRUE;
05262    }
05263 
05264    /* Check for other floating point powers */
05265    switch (TCON_ty(t)) {
05266     case MTYPE_F4:
05267       exponent = (TCON_v0(t) & 0x7f800000) >> 23;
05268       mant = TCON_v0(t) & 0x007fffff;
05269       return mant == 0 && exponent != 0 && exponent != 255;
05270 
05271     case MTYPE_F8:
05272       exponent = (TCON_v1(t) & 0x7ff00000) >> 20;
05273       mant = (TCON_v1(t) & 0x000fffff) | TCON_v0(t);
05274       return mant==0 && exponent != 0 && exponent != 2047;
05275 
05276     case MTYPE_F10:
05277       return FALSE;
05278 
05279 #ifdef TARG_NEEDS_QUAD_OPS
05280     case MTYPE_FQ:
05281       /* assumes quads are implemented as
05282        * struct quad {
05283        *  double hi,lo
05284        * }
05285        */
05286       exponent = (TCON_v1(t) & 0x7ff00000) >> 20;
05287       mant = (TCON_v1(t) & 0x000fffff) | TCON_v0(t) | TCON_v2(t) | TCON_v3(t);
05288       return mant==0 && exponent != 0 && exponent != 2047;
05289 #endif
05290    }
05291 
05292    return FALSE;
05293 }
05294 
05295 
05296 #ifndef MONGOOSE_BE
05297 /* ====================================================================
05298  *
05299  * Targ_Contains_One_Bit_On
05300  *
05301  * Determine whether the TCON contains an integral value with only
05302  * one bit on.
05303  *
05304  * If onebit is not NULL then return the bit number of the bit
05305  * that is on.
05306  *
05307  *
05308  * ====================================================================
05309  */
05310 
05311 BOOL
05312 Targ_Contains_One_Bit_On ( TCON t, INT32 *onebit )
05313 {
05314   INT64 cval;
05315   INT32 i;
05316 
05317   if ( Targ_Is_Integral ( t, &cval ) ) {
05318     if ( cval == 0 ) return FALSE;
05319     if ( cval != ( cval & ~(cval-1) ) ) return FALSE;
05320     for (i=0; i< 64; i++) {
05321       if (cval & 0x1 ) { 
05322   if (onebit != NULL) *onebit = i;
05323   return TRUE;
05324       }
05325       cval = cval >> 1;
05326     } /* for i */
05327   }
05328   return FALSE;
05329 }
05330 
05331 /* ====================================================================
05332  *
05333  * Targ_Determine_High_Bit
05334  *
05335  * Determine the most significant bit that is on, with 0 being the
05336  * least-sig bit, and type's_size - 1 being the most-sig bit.
05337  * If no bits are on, return FALSE.
05338  *
05339  * ====================================================================
05340  */
05341 
05342 BOOL
05343 Targ_Determine_High_Bit ( TCON t, INT32 *highbit )
05344 {
05345   INT64 cval;
05346   INT32 i;
05347 
05348   if ( Targ_Is_Integral ( t, &cval ) ) {
05349     UINT64 testbit;
05350     if ( cval == 0 ) return FALSE;
05351 
05352     testbit = ((INT64)1) << MTYPE_size_min(TCON_ty(t))-1;
05353     for ( i = MTYPE_size_min(TCON_ty(t))-1; i >= 0; i-- ) {
05354       if ( (cval & testbit) != 0 ) {
05355   if ( highbit != NULL ) *highbit = i;
05356   return TRUE;
05357       }
05358 
05359       testbit = testbit >> 1;
05360     }
05361   }
05362   return FALSE;
05363 }
05364 #endif /* MONGOOSE_BE */
05365 
05366 /* ====================================================================
05367  *
05368  * Hash_TCON
05369  *
05370  * Hash a TCON into a 32-bit integer modulo another integer.
05371  *
05372  * ====================================================================
05373  */
05374 
05375 UINT32
05376 Hash_TCON ( TCON * t, UINT32 modulus )
05377 {
05378   UINT32 hash = TCON_ty(*t);
05379   UINT32 rhash;
05380   INT32 i;
05381   char *s;
05382 
05383   switch (TCON_ty(*t)) {
05384     case MTYPE_B:
05385     case MTYPE_I1:
05386     case MTYPE_I2:
05387     case MTYPE_I4:
05388     case MTYPE_U1:
05389     case MTYPE_U2:
05390     case MTYPE_U4:
05391     case MTYPE_F4:
05392       hash += TCON_v0(*t);
05393       break;
05394     case MTYPE_I8:
05395     case MTYPE_U8:
05396     case MTYPE_F8:
05397       hash += TCON_v0(*t) + TCON_v1(*t);
05398       break;
05399     case MTYPE_F10:
05400     case MTYPE_FQ:
05401       hash += TCON_v0(*t) + TCON_v1(*t) + TCON_v2(*t) + TCON_v3(*t);
05402       break;
05403     case MTYPE_C4:
05404       hash += TCON_v0(*t);
05405       hash += TCON_iv0(*t);
05406       break;
05407     case MTYPE_C8:
05408       hash += TCON_v0(*t) + TCON_v1(*t);
05409       hash += TCON_iv0(*t) + TCON_iv1(*t);
05410       break;
05411     case MTYPE_C10:
05412     case MTYPE_CQ:
05413       hash += TCON_v0(*t) + TCON_v1(*t) + TCON_v2(*t) + TCON_v3(*t);
05414       hash += TCON_iv0(*t) + TCON_iv1(*t) + TCON_iv2(*t) + TCON_iv3(*t);
05415       break;
05416     case MTYPE_STRING:
05417       s = Index_to_char_array (TCON_cp (*t));
05418       for ( i = 0; i < TCON_len(*t); i++, s++ ) {
05419   hash += (*s) << ((i % 4) * 8);
05420       }
05421       break;
05422     default:
05423       ErrMsg ( EC_Inv_Mtype, Mtype_Name(TCON_ty(*t)), "Hash_TCON" );
05424       return 0;
05425   }
05426 
05427   if ( hash == 0 ) {
05428     /* Avoid later recalculation: */
05429     hash = MTYPE_LAST;
05430   }
05431   rhash = hash % modulus;
05432 
05433 #ifdef Is_True_On
05434   if ( Get_Trace ( TP_MISC, 16 ) ) {
05435     fprintf ( TFile, "<tc> Hashing TCON ty=%d, %u mod %u = %u\n",
05436         TCON_ty(*t), hash, modulus, rhash );
05437   }
05438 #endif
05439 
05440   return rhash;
05441 } /* Hash_TCON */
05442 
05443 /* ====================================================================
05444  *
05445  * Handle_Fortran_Constants 
05446  * 
05447  * Process context dependent floating point constants (FORTRAN ONLY)
05448  *
05449  * ====================================================================
05450  */
05451 
05452 #ifdef FRONT_END_FORTRAN
05453 BOOL Handle_Fortran_Constants(ND *t, TY *to_ty) 
05454 {
05455     return FALSE;
05456 } /* Handle_Fortran_Constants */
05457 #endif /* FRONT_END_FORTRAN */
05458 
05459 
05460 /*
05461  *   Targ_IntrinsicOp
05462  *
05463  *  fold intrinsics. Arguments are essentially the same as Targ_Op and Targ_WhirlOp
05464  *
05465  */
05466 
05467 
05468 TCON Targ_IntrinsicOp ( UINT32 intrinsic, TCON c[], BOOL *folded)
05469 {
05470    TCON c0,t;
05471    *folded = TRUE;
05472 
05473    c0 = c[0]; /* to get the type information by default */
05474 
05475 
05476 #define DEG_TO_RAD (M_PI/180.0)
05477 #define RAD_TO_DEG (180.0/M_PI)
05478 
05479 #ifdef QUAD_PRECISION_SUPPORTED
05480 #define M_PIL  3.141592653589793238462643383279531l
05481 #define DEG_TO_RADQ (M_PIL/180.0l)
05482 #define RAD_TO_DEGQ (180.0l/M_PIL)
05483 #endif
05484 
05485    switch ((INTRINSIC) intrinsic) {
05486 
05487     case INTRN_I4EXPEXPR:
05488       c0 = Targ_Power(c[0],c[1],folded,MTYPE_I4);
05489       break;
05490     case INTRN_I8EXPEXPR:
05491       c0 = Targ_Power(c[0],c[1],folded,MTYPE_I8);
05492       break;
05493     case INTRN_F4EXPEXPR:
05494     case INTRN_F4I4EXPEXPR:
05495     case INTRN_F4I8EXPEXPR:
05496       c0 = Targ_Power(c[0],c[1],folded,MTYPE_F4);
05497       break;
05498     case INTRN_F8EXPEXPR:
05499     case INTRN_F8I4EXPEXPR:
05500     case INTRN_F8I8EXPEXPR:
05501       c0 = Targ_Power(c[0],c[1],folded,MTYPE_F8);
05502       break;
05503     case INTRN_FQEXPEXPR:
05504     case INTRN_FQI4EXPEXPR:
05505     case INTRN_FQI8EXPEXPR:
05506       c0 = Targ_Power(c[0],c[1],folded,MTYPE_FQ);
05507       break;
05508     case INTRN_C4EXPEXPR:
05509     case INTRN_C4I4EXPEXPR:
05510     case INTRN_C4I8EXPEXPR:
05511       c0 = Targ_Power(c[0],c[1],folded,MTYPE_C4);
05512       break;
05513     case INTRN_C8EXPEXPR:
05514     case INTRN_C8I4EXPEXPR:
05515     case INTRN_C8I8EXPEXPR:
05516       c0 = Targ_Power(c[0],c[1],folded,MTYPE_C8);
05517       break;
05518     case INTRN_CQEXPEXPR:
05519     case INTRN_CQI4EXPEXPR:
05520     case INTRN_CQI8EXPEXPR:
05521       c0 = Targ_Power(c[0],c[1],folded,MTYPE_CQ);
05522       break;
05523 
05524 
05525     case INTRN_I1DIM:
05526     case INTRN_I2DIM:
05527     case INTRN_I4DIM:
05528       if (TCON_I4(c[0]) > TCON_I4(c[1])) {
05529    TCON_I4(c0) = TCON_I4(c[0]) - TCON_I4(c[1]);
05530       } else {
05531    TCON_I4(c0) = 0;
05532       }
05533       break;
05534     case INTRN_I8DIM:
05535       if (TCON_I8(c[0]) > TCON_I8(c[1])) {
05536    TCON_I8(c0) = TCON_I8(c[0]) - TCON_I8(c[1]);
05537       } else {
05538    TCON_I8(c0) = 0;
05539       }
05540       break;
05541 
05542     case INTRN_I1SIGN:
05543     case INTRN_I2SIGN:
05544     case INTRN_I4SIGN:
05545       if (TCON_I4(c0) < 0) TCON_I4(c0) = -TCON_I4(c0);
05546       if (TCON_I4(c[1]) < 0) TCON_I4(c0) = -TCON_I4(c0);
05547       break;
05548 
05549     case INTRN_I8SIGN:
05550       if (TCON_I8(c0) < 0) TCON_I8(c0) = -TCON_I8(c0);
05551       if (TCON_I8(c[1]) < 0) TCON_I8(c0) = -TCON_I8(c0);
05552       break;
05553 
05554     case INTRN_F4SIGN:
05555       c0 = Targ_WhirlOp(OPC_F4ABS,c0,c0,folded);
05556       if (TCON_R4(c[1]) < 0) TCON_R4(c0) = -TCON_R4(c0);
05557       break;
05558 
05559     case INTRN_F8SIGN:
05560       c0 = Targ_WhirlOp(OPC_F8ABS,c0,c0,folded);
05561       if (TCON_R8(c[1]) < 0) TCON_R8(c0) = -TCON_R8(c0);
05562       break;
05563 
05564     case INTRN_FQSIGN:
05565       c0 = Targ_WhirlOp(OPC_FQABS,c0,c0,folded);
05566       t = Targ_WhirlOp(OPC_I4FQLT,c[1],Quad_Zero_Tcon,folded);
05567       if (TCON_I4(t)) c0 = Targ_WhirlOp(OPC_FQNEG,c0,c0,folded);
05568       break;
05569 
05570     case INTRN_I2F4NINT:
05571       c0 = Targ_Conv(MTYPE_I2,Targ_WhirlOp(OPC_I4F4RND,c[0],c[0],folded));
05572       break;
05573 
05574     case INTRN_I4F4NINT:
05575       c0 = Targ_WhirlOp(OPC_I4F4RND,c[0],c[0],folded);
05576       break;
05577 
05578     case INTRN_I8F4NINT:
05579       c0 = Targ_WhirlOp(OPC_I8F4RND,c[0],c[0],folded);
05580       break;
05581 
05582     case INTRN_I2F8IDNINT:
05583       c0 = Targ_Conv(MTYPE_I2,Targ_WhirlOp(OPC_I4F8RND,c[0],c[0],folded));
05584       break;
05585 
05586     case INTRN_I4F8IDNINT:
05587       c0 = Targ_WhirlOp(OPC_I4F8RND,c[0],c[0],folded);
05588       break;
05589 
05590     case INTRN_I8F8IDNINT:
05591       c0 = Targ_WhirlOp(OPC_I8F8RND,c[0],c[0],folded);
05592       break;
05593 
05594     case INTRN_I2FQIQNINT:
05595       c0 = Targ_Conv(MTYPE_I2,Targ_WhirlOp(OPC_I4FQRND,c[0],c[0],folded));
05596       break;
05597 
05598     case INTRN_I4FQIQNINT:
05599       c0 = Targ_WhirlOp(OPC_I4FQRND,c[0],c[0],folded);
05600       break;
05601 
05602     case INTRN_I8FQIQNINT:
05603       c0 = Targ_WhirlOp(OPC_I8FQRND,c[0],c[0],folded);
05604       break;
05605 
05606     case INTRN_I1BITS:
05607     case INTRN_I2BITS:
05608     case INTRN_I4BITS:
05609       {
05610    INT64 mask,bits,one=1;
05611    mask = (one << TCON_U4(c[2])) - 1;
05612    bits = TCON_U4(c0) >> TCON_U4(c[1]);
05613    TCON_U4(c0) = mask & bits;
05614       }
05615       break;
05616 
05617     case INTRN_I8BITS:
05618       {
05619    INT64 mask,bits,one=1;
05620    mask = (one << TCON_U8(c[2])) - 1;
05621    bits = TCON_U8(c0) >> TCON_U8(c[1]);
05622    TCON_U8(c0) = mask & bits;
05623       }
05624       break;
05625 
05626     case INTRN_I1BSET:
05627     case INTRN_I2BSET:
05628     case INTRN_I4BSET:
05629       TCON_I4(c0) |= (1 << TCON_I4(c[1]));
05630       break;
05631 
05632     case INTRN_I8BSET:
05633       {
05634    INT64 one=1;
05635    TCON_I8(c0) |= (one << TCON_I8(c[1]));
05636       }
05637       break;
05638 
05639     case INTRN_I1BCLR:
05640     case INTRN_I2BCLR:
05641     case INTRN_I4BCLR:
05642       TCON_I4(c0) &= ~(1 << TCON_I4(c[1]));
05643       break;
05644 
05645     case INTRN_I8BCLR:
05646       {
05647    INT64 one=1;
05648    TCON_I8(c0) &= ~(one << TCON_I8(c[1]));
05649       }
05650       break;
05651 
05652     case INTRN_I1BTEST:
05653     case INTRN_I2BTEST:
05654     case INTRN_I4BTEST:
05655       {
05656    INT32 test;
05657    test = TCON_I4(c0) & (1<<TCON_I4(c[1]));
05658    TCON_I4(c0) = (test != 0); TCON_v1(c0) = 0;
05659    TCON_ty(c0) = LOGICAL_MTYPE;
05660       }
05661       break;
05662 
05663     case INTRN_I8BTEST:
05664       {
05665    INT64 test,one=1;
05666    test = TCON_I8(c0) & (one<<TCON_I8(c[1]));
05667    TCON_I4(c0) = (test != 0); TCON_v1(c0) = 0;
05668    TCON_ty(c0) = LOGICAL_MTYPE;
05669       }
05670       break;
05671       
05672     case INTRN_I1SHL:
05673       TCON_I4(c0) = (TCON_I4(c0) << TCON_I4(c[1]))&0xff;
05674       break;
05675 
05676     case INTRN_I2SHL:
05677       TCON_I4(c0) = (TCON_I4(c0) << TCON_I4(c[1]))&0xffff;
05678       break;
05679 
05680     case INTRN_I1SHFT:
05681       if (TCON_I4(c[1]) >= 0) {
05682    TCON_I4(c0) <<= TCON_I4(c[1]);
05683       } else {
05684    TCON_U4(c0) >>= (-TCON_I4(c[1]));
05685       }
05686       TCON_U4(c0) &= 0xff;
05687       break;
05688 
05689     case INTRN_I2SHFT:
05690       if (TCON_I4(c[1]) >= 0) {
05691    TCON_I4(c0) <<= TCON_I4(c[1]);
05692       } else {
05693    TCON_U4(c0) >>= (-TCON_I4(c[1]));
05694       }
05695       TCON_U4(c0) &= 0xffff;
05696       break;
05697 
05698     case INTRN_I4SHFT:
05699       if (TCON_I4(c[1]) >= 0) {
05700    TCON_I4(c0) <<= TCON_I4(c[1]);
05701       } else {
05702    TCON_U4(c0) >>= (-TCON_I4(c[1]));
05703       }
05704       break;
05705 
05706     case INTRN_I8SHFT:
05707       if (TCON_I8(c[1]) >= 0) {
05708    TCON_I8(c0) <<= TCON_I8(c[1]);
05709       } else {
05710    TCON_U8(c0) >>= (-TCON_I8(c[1]));
05711       }
05712       break;
05713 
05714     case INTRN_I1SHFTC:
05715     case INTRN_I2SHFTC:
05716     case INTRN_I4SHFTC:
05717       {
05718    UINT32 mask,size,t,sl,sr;
05719    size = TCON_I4(c[2]);
05720    if (size == 32) {
05721       mask = (UINT32)-1;
05722    } else {
05723       mask = (1U << size) - 1;
05724    }
05725    if (TCON_I4(c[1]) >= 0) {
05726       sl = TCON_I4(c[1]);
05727    } else {
05728       sl = size + TCON_I4(c[1]);
05729    }
05730    sr = size - sl;
05731    t = TCON_I4(c0) & mask;
05732    t = ((t >> sl) | (t << sr)) & mask;
05733    TCON_I4(c0) = t | (TCON_I4(c0) & (~mask));
05734       }
05735       break;
05736 
05737 
05738     case INTRN_I8SHFTC:
05739       {
05740    UINT64 mask,size,t,sl,sr;
05741    size = TCON_I8(c[2]);
05742    if (size==64) {
05743       mask = (UINT64)-1;
05744    } else {
05745       mask = (1ULL << size) - 1;
05746    }
05747    if (TCON_I8(c[1]) >= 0) {
05748       sl = TCON_I8(c[1]);
05749    } else {
05750       sl = size + TCON_I8(c[1]);
05751    }
05752    sr = size - sl;
05753    t = TCON_I8(c0) & mask;
05754    t = ((t >> sl) | (t << sr)) & mask;
05755    TCON_I8(c0) = t | (TCON_I8(c0) & (~mask));
05756       }
05757       break;
05758 
05759     case INTRN_I8DIVFLOOR:
05760       if (TCON_I8(c[1]) == 0) {
05761    *folded = FALSE;
05762       } else {
05763    INT64 q,sign;
05764    q = TCON_I8(c[0]) / TCON_I8(c[1]);
05765    sign = TCON_I8(c[0]) ^ TCON_I8(c[1]);
05766    if (sign < 0 && q*TCON_I8(c[1]) != TCON_I8(c[0])) {
05767       q -= 1;
05768    }
05769    TCON_I8(c0) = q;
05770       }
05771       break;
05772 
05773     case INTRN_I4DIVFLOOR:
05774       if (TCON_I4(c[1]) == 0) {
05775    *folded = FALSE;
05776       } else {
05777    INT32 q,sign;
05778    q = TCON_I4(c[0]) / TCON_I4(c[1]);
05779    sign = TCON_I4(c[0]) ^ TCON_I4(c[1]);
05780    if (sign < 0 && q*TCON_I4(c[1]) != TCON_I4(c[0])) {
05781       q -= 1;
05782    }
05783    TCON_I4(c0) = q;
05784       }
05785       break;
05786 
05787     case INTRN_U8DIVFLOOR:
05788       if (TCON_U8(c[1]) == 0) {
05789    *folded = FALSE;
05790       } else {
05791    TCON_U8(c0)  = TCON_U8(c[0]) / TCON_U8(c[1]);
05792       }
05793       break;
05794 
05795     case INTRN_U4DIVFLOOR:
05796       if (TCON_U4(c[1]) == 0) {
05797    *folded = FALSE;
05798       } else {
05799    TCON_U4(c0) = TCON_U4(c[0]) / TCON_U4(c[1]);
05800       }
05801       break;
05802      
05803     case INTRN_I8DIVCEIL:
05804       if (TCON_I8(c[1]) == 0) {
05805    *folded = FALSE;
05806       } else {
05807    INT64 q,sign;
05808    q = TCON_I8(c[0]) / TCON_I8(c[1]);
05809    sign = TCON_I8(c[0]) ^ TCON_I8(c[1]);
05810    if (sign >= 0 && q*TCON_I8(c[1]) != TCON_I8(c[0])) {
05811       q += 1;
05812    }
05813    TCON_I8(c0) = q;
05814       }
05815       break;
05816 
05817     case INTRN_I4DIVCEIL:
05818       if (TCON_I4(c[1]) == 0) {
05819    *folded = FALSE;
05820       } else {
05821    INT32 q,sign;
05822    q = TCON_I4(c[0]) / TCON_I4(c[1]);
05823    sign = TCON_I4(c[0]) ^ TCON_I4(c[1]);
05824    if (sign >= 0 && q*TCON_I4(c[1]) != TCON_I4(c[0])) {
05825       q += 1;
05826    }
05827    TCON_I4(c0) = q;
05828       }
05829       break;
05830 
05831     case INTRN_U8DIVCEIL:
05832       if (TCON_U8(c[1]) == 0) {
05833    *folded = FALSE;
05834       } else {
05835    UINT64 q;
05836    q = TCON_U8(c[0]) / TCON_U8(c[1]);
05837    if (q*TCON_U8(c[1]) != TCON_U8(c[0])) {
05838       q += 1;
05839    }
05840    TCON_U8(c0) = q;
05841       }
05842       break;
05843 
05844     case INTRN_U4DIVCEIL:
05845       if (TCON_U4(c[1]) == 0) {
05846    *folded = FALSE;
05847       } else {
05848    UINT32 q;
05849    q = TCON_U4(c[0]) / TCON_U4(c[1]);
05850    if (q*TCON_U4(c[1]) != TCON_U4(c[0])) {
05851       q += 1;
05852    }
05853    TCON_U4(c0) = q;
05854       }
05855       break;
05856 
05857 
05858     case INTRN_F4DIM:
05859       if (TCON_R4(c[0]) > TCON_R4(c[1])) {
05860    TCON_R4(c0) = TCON_R4(c[0]) - TCON_R4(c[1]);
05861       } else {
05862    TCON_R4(c0) = 0.0;
05863       }
05864       break;
05865 
05866     case INTRN_F8DIM:
05867       if (TCON_R8(c[0]) > TCON_R8(c[1])) {
05868    TCON_R8(c0) = TCON_R8(c[0]) - TCON_R8(c[1]);
05869       } else {
05870    TCON_R8(c0) = 0.0;
05871       }
05872       break;
05873 
05874     case INTRN_FQDIM:
05875       c0 = Targ_WhirlOp(OPC_FQSUB,c0,c[1],folded);
05876       t = Targ_WhirlOp(OPC_I4FQLT,c0,Quad_Zero_Tcon,folded);
05877       if (TCON_I4(t)) c0 = Quad_Zero_Tcon;
05878       break;
05879 
05880     case INTRN_F4AINT:
05881       t = Targ_WhirlOp(OPC_F4ABS,c[0],c[0],folded);
05882       if ((INT32) TCON_R4(t) < (1<<30)) {
05883    TCON_R4(c0) = (INT32) TCON_R4(c0);
05884       }
05885       break;
05886 
05887     case INTRN_F8AINT:
05888       t = Targ_WhirlOp(OPC_F8ABS,c[0],c[0],folded);
05889       if ((INT64) TCON_R8(t) < (1LL << 62)) {
05890    TCON_R8(c0) = (INT64) TCON_R8(c0);
05891       }
05892       break;
05893 
05894     case INTRN_F4ANINT:
05895       if (TCON_R4(c0) < 0) {
05896    TCON_R4(c0) -= 0.5;
05897       } else {
05898    TCON_R4(c0) += 0.5;
05899       }
05900       c0 = Targ_IntrinsicOp(INTRN_F4AINT,&c0,folded);
05901       break;
05902     case INTRN_F8ANINT:
05903       if (TCON_R8(c0) < 0) {
05904    TCON_R8(c0) -= 0.5;
05905       } else {
05906    TCON_R8(c0) += 0.5;
05907       }
05908       c0 = Targ_IntrinsicOp(INTRN_F8AINT,&c0,folded);
05909       break;
05910 
05911     case INTRN_F4EXP:
05912       TCON_R4(c0) = expf(TCON_R4(c0));
05913       break;
05914     case INTRN_F8EXP:
05915       TCON_R8(c0) = exp(TCON_R8(c0));
05916       break;
05917       
05918     case INTRN_F4LOG:
05919       TCON_R4(c0) = logf(TCON_R4(c0));
05920       break;
05921     case INTRN_F8LOG:
05922       TCON_R8(c0) = log(TCON_R8(c0));
05923       break;
05924       
05925     case INTRN_F4LOG10:
05926       TCON_R4(c0) = log10f(TCON_R4(c0));
05927       break;
05928     case INTRN_F8LOG10:
05929       TCON_R8(c0) = log10(TCON_R8(c0));
05930       break;
05931 
05932     case INTRN_F4COS:
05933       TCON_R4(c0) = cosf(TCON_R4(c0));
05934       break;
05935     case INTRN_F8COS:
05936       TCON_R8(c0) = cos(TCON_R8(c0));
05937       break;
05938 
05939     case INTRN_F4SIN:
05940       TCON_R4(c0) = sinf(TCON_R4(c0));
05941       break;
05942     case INTRN_F8SIN:
05943       TCON_R8(c0) = sin(TCON_R8(c0));
05944       break;
05945 
05946     case INTRN_F4TAN:
05947       TCON_R4(c0) = tanf(TCON_R4(c0));
05948       break;
05949     case INTRN_F8TAN:
05950       TCON_R8(c0) = tan(TCON_R8(c0));
05951       break;
05952 
05953     case INTRN_F4COSD:
05954       TCON_R4(c0) = cosf(DEG_TO_RAD*TCON_R4(c0));
05955       break;
05956     case INTRN_F8COSD:
05957       TCON_R8(c0) = cos(DEG_TO_RAD*TCON_R8(c0));
05958       break;
05959 
05960     case INTRN_F4SIND:
05961       TCON_R4(c0) = sinf(DEG_TO_RAD*TCON_R4(c0));
05962       break;
05963     case INTRN_F8SIND:
05964       TCON_R8(c0) = sin(DEG_TO_RAD*TCON_R8(c0));
05965       break;
05966 
05967     case INTRN_F4TAND:
05968       TCON_R4(c0) = tanf(DEG_TO_RAD*TCON_R4(c0));
05969       break;
05970     case INTRN_F8TAND:
05971       TCON_R8(c0) = tan(DEG_TO_RAD*TCON_R8(c0));
05972       break;
05973 
05974 
05975     case INTRN_F4ACOS:
05976       TCON_R4(c0) = acosf(TCON_R4(c0));
05977       break;
05978     case INTRN_F8ACOS:
05979       TCON_R8(c0) = acos(TCON_R8(c0));
05980       break;
05981 
05982     case INTRN_F4ASIN:
05983       TCON_R4(c0) = asinf(TCON_R4(c0));
05984       break;
05985     case INTRN_F8ASIN:
05986       TCON_R8(c0) = asin(TCON_R8(c0));
05987       break;
05988 
05989     case INTRN_F4ATAN:
05990       TCON_R4(c0) = atanf(TCON_R4(c0));
05991       break;
05992     case INTRN_F8ATAN:
05993       TCON_R8(c0) = atan(TCON_R8(c0));
05994       break;
05995 
05996     case INTRN_F4ACOSD:
05997       TCON_R4(c0) = RAD_TO_DEG*acosf(TCON_R4(c0));
05998       break;
05999     case INTRN_F8ACOSD:
06000       TCON_R8(c0) = RAD_TO_DEG*acos(TCON_R8(c0));
06001       break;
06002 
06003     case INTRN_F4ASIND:
06004       TCON_R4(c0) = RAD_TO_DEG*asinf(TCON_R4(c0));
06005       break;
06006     case INTRN_F8ASIND:
06007       TCON_R8(c0) = RAD_TO_DEG*asin(TCON_R8(c0));
06008       break;
06009 
06010     case INTRN_F4ATAND:
06011       TCON_R4(c0) = RAD_TO_DEG*atanf(TCON_R4(c0));
06012       break;
06013     case INTRN_F8ATAND:
06014       TCON_R8(c0) = RAD_TO_DEG*atan(TCON_R8(c0));
06015       break;
06016 
06017     case INTRN_F4COSH:
06018       TCON_R4(c0) = coshf(TCON_R4(c0));
06019       break;
06020     case INTRN_F8COSH:
06021       TCON_R8(c0) = cosh(TCON_R8(c0));
06022       break;
06023 
06024     case INTRN_F4SINH:
06025       TCON_R4(c0) = sinhf(TCON_R4(c0));
06026       break;
06027     case INTRN_F8SINH:
06028       TCON_R8(c0) = sinh(TCON_R8(c0));
06029       break;
06030 
06031     case INTRN_F4TANH:
06032       TCON_R4(c0) = tanhf(TCON_R4(c0));
06033       break;
06034     case INTRN_F8TANH:
06035       TCON_R8(c0) = tanh(TCON_R8(c0));
06036       break;
06037 
06038     case INTRN_F4ATAN2:
06039       TCON_R4(c0) = atan2f(TCON_R4(c0),TCON_R4(c[1]));
06040       break;
06041     case INTRN_F8ATAN2:
06042       TCON_R8(c0) = atan2(TCON_R8(c0),TCON_R8(c[1]));
06043       break;
06044 
06045     case INTRN_F4ATAN2D:
06046       TCON_R4(c0) = RAD_TO_DEG*atan2f(TCON_R4(c0),TCON_R4(c[1]));
06047       break;
06048     case INTRN_F8ATAN2D:
06049       TCON_R8(c0) = RAD_TO_DEG*atan2(TCON_R8(c0),TCON_R8(c[1]));
06050       break;
06051 
06052     case
osprey/common/com/ia64/targ_const.cxx
