Open64: osprey/be/opt/opt_u64_lower.cxx Source File

00001 //-*-c++-*-
00002 
00003 /*
00004  * Copyright 2003, 2004, 2005, 2006 PathScale, Inc.  All Rights Reserved.
00005  */
00006 
00007 // ====================================================================
00008 // ====================================================================
00009 //
00010 // Module: opt_u64_lower.cxx
00011 // $Revision: 1.1.1.1 $
00012 // $Date: 2005/10/21 19:00:00 $
00013 // $Author: marcel $
00014 // $Source: /proj/osprey/CVS/open64/osprey1.0/be/opt/opt_u64_lower.cxx,v $
00015 //
00016 // ====================================================================
00017 //
00018 // Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00019 //
00020 // This program is free software; you can redistribute it and/or modify
00021 // it under the terms of version 2 of the GNU General Public License as
00022 // published by the Free Software Foundation.
00023 //
00024 // This program is distributed in the hope that it would be useful, but
00025 // WITHOUT ANY WARRANTY; without even the implied warranty of
00026 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00027 //
00028 // Further, this software is distributed without any warranty that it
00029 // is free of the rightful claim of any third person regarding
00030 // infringement  or the like.  Any license provided herein, whether
00031 // implied or otherwise, applies only to this software file.  Patent
00032 // licenses, if any, provided herein do not apply to combinations of
00033 // this program with other software, or any other product whatsoever.
00034 //
00035 // You should have received a copy of the GNU General Public License
00036 // along with this program; if not, write the Free Software Foundation,
00037 // Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
00038 //
00039 // Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00040 // Mountain View, CA 94043, or:
00041 //
00042 // http://www.sgi.com
00043 //
00044 // For further information regarding this notice, see:
00045 //
00046 // http://oss.sgi.com/projects/GenInfo/NoticeExplan
00047 //
00048 // ====================================================================
00049 //
00050 // Description:
00051 //
00052 // Lowering module for unsigned 64-bit ISA working in coderep
00053 //
00054 // ====================================================================
00055 // ====================================================================
00056 
00057 
00058 #ifdef USE_PCH
00059 #include "opt_pch.h"
00060 #endif // USE_PCH
00061 #pragma hdrstop
00062 
00063 #include "defs.h"
00064 #include "errors.h"
00065 #include "erglob.h"
00066 #include "tracing.h"  /* for TFile */
00067 
00068 #include "opt_defs.h"
00069 #include "opt_cfg.h"
00070 #include "opt_ssa.h"
00071 #include "opt_main.h"
00072 #include "opt_sym.h"
00073 #include "opt_htable.h"
00074 
00075 #define U64_LOWER_alloc_stack(x) Alloc_stack_cr(x->Extra_ptrs_used())
00076 
00077 #include "u64_lower_template.h"
00078 
00079 static CODEMAP *htable;
00080 
00081 // ====================================================================
00082 // specialized version of support routines used in the U64_LOWER template
00083 // ==================================================================== 
00084 
00085 inline void
00086 U64_LOWER_delete(CODEREP *cr) {}
00087 
00088 INT
00089 U64_LOWER_kid_count(const CODEREP *cr) { 
00090   if (cr->Kind() == CK_OP)
00091     return cr->Kid_count(); 
00092   if (cr->Kind() != CK_IVAR)
00093     return 0;
00094   if (cr->Ilod_base() == NULL)
00095     return 0;
00096   return cr->Opr() == OPR_MLOAD ? 2 : 1;
00097 }
00098 
00099 CODEREP *
00100 U64_LOWER_kid(const CODEREP *cr, INT i) { 
00101   if (cr->Kind() == CK_OP)
00102     return cr->Opnd(i); 
00103   if (cr->Kind() != CK_IVAR)
00104     return NULL;
00105   return i == 0 ? cr->Ilod_base() : cr->Mload_size();
00106 }
00107 
00108 void
00109 U64_LOWER_set_kid(CODEREP *cr, INT i, CODEREP *x) { 
00110   if (cr->Kind() == CK_OP)
00111     cr->Set_opnd(i, x); 
00112   else if (cr->Kind() == CK_IVAR) {
00113     if (i == 0)
00114       cr->Set_ilod_base(x);
00115     else cr->Set_mload_size(x);
00116   }
00117 }
00118 
00119 inline CODEREP *
00120 U64_LOWER_kid0(const CODEREP *cr) { return U64_LOWER_kid(cr, 0); }
00121 
00122 inline void
00123 U64_LOWER_set_kid0(CODEREP *cr, CODEREP *x) { U64_LOWER_set_kid(cr, 0, x); }
00124 
00125 inline CODEREP *
00126 U64_LOWER_kid1(const CODEREP *cr) { return U64_LOWER_kid(cr, 1); }
00127 
00128 inline void
00129 U64_LOWER_set_kid1(CODEREP *cr, CODEREP *x) { U64_LOWER_set_kid(cr, 1, x); }
00130 
00131 inline CODEREP *
00132 U64_LOWER_kid2(const CODEREP *cr) { return U64_LOWER_kid(cr, 2); }
00133 
00134 inline void
00135 U64_LOWER_set_kid2(CODEREP *cr, CODEREP *x) { U64_LOWER_set_kid(cr, 2, x); }
00136 
00137 OPERATOR
00138 U64_LOWER_operator(const CODEREP *cr) { 
00139     switch (cr->Kind()) {
00140     case CK_OP:
00141     case CK_IVAR:
00142       return cr->Opr();
00143     case CK_LDA:
00144       return cr->Is_flag_set(CF_LDA_LABEL) ? OPR_LDA_LABEL : OPR_LDA;
00145     case CK_CONST:
00146       return OPR_INTCONST;
00147     case CK_RCONST:
00148       return OPR_CONST;
00149     case CK_VAR:
00150       return cr->Bit_field_valid() ? OPR_LDBITS : OPR_LDID;
00151     }
00152     return OPERATOR_UNKNOWN;
00153 }
00154 
00155 inline TYPE_ID
00156 U64_LOWER_rtype(const CODEREP *cr) { return cr->Dtyp(); }
00157 
00158 inline void
00159 U64_LOWER_set_rtype(CODEREP *cr, TYPE_ID t) { 
00160   if (! inCODEKIND(cr->Kind(), CK_CONST | CK_VAR | CK_IVAR))
00161     cr->Set_dtyp_strictly(t); 
00162 }
00163 
00164 inline TYPE_ID
00165 U64_LOWER_desc(const CODEREP *cr) { return cr->Dsctyp(); }
00166 
00167 inline void
00168 U64_LOWER_set_desc(CODEREP *cr, TYPE_ID t) { 
00169   if (! inCODEKIND(cr->Kind(), CK_CONST | CK_VAR | CK_IVAR))
00170     cr->Set_dsctyp(t); 
00171 }
00172 
00173 inline INT
00174 U64_LOWER_cvtl_bits(const CODEREP *cr) { return cr->Offset(); }
00175 
00176 inline void
00177 U64_LOWER_set_cvtl_bits(CODEREP *cr, INT i) { cr->Set_offset(i); }
00178 
00179 inline INT16
00180 U64_LOWER_bit_size(const CODEREP *cr) 
00181 { 
00182   if (cr->Kind() == CK_OP) 
00183     return cr->Op_bit_size(); 
00184   else if (cr->Kind() == CK_IVAR) 
00185     return cr->I_bit_size(); 
00186   else return cr->Bit_size(); 
00187 }
00188 
00189 inline INT16
00190 U64_LOWER_bit_offset(const CODEREP *cr) 
00191 { 
00192   if (cr->Kind() == CK_OP) 
00193     return cr->Op_bit_offset(); 
00194   else if (cr->Kind() == CK_IVAR) 
00195     return cr->I_bit_offset(); 
00196   else return cr->Bit_offset(); 
00197 }
00198 
00199 inline INT64
00200 U64_LOWER_const_val(const CODEREP *cr) { return cr->Const_val(); }
00201 
00202 inline void
00203 U64_LOWER_set_const_val(CODEREP *cr, INT64 i) { cr->Set_const_val(i); }
00204 
00205 inline ST_CLASS
00206 U64_LOWER_class(const CODEREP *cr) { 
00207   return ST_class(htable->Sym()->Aux_stab_entry(cr->Aux_id())->St()); }
00208 
00209 inline void
00210 U64_LOWER_copy_node(CODEREP *newcr, CODEREP *oldcr) { newcr->Copy(*oldcr); }
00211 
00212 CODEREP *
00213 U64_LOWER_form_node(CODEREP *cr, CODEREP *old_cr) { 
00214   // if any operand in old_cr has been changed, cannot re-use old_cr
00215   // (cannot just call Match because does not need to check mu/chi
00216   BOOL changed = FALSE;
00217   switch (old_cr->Kind()) {
00218   case CK_CONST: case CK_RCONST: case CK_LDA: case CK_VAR:
00219     return old_cr;
00220   case CK_IVAR:
00221     if (! OPERATOR_is_scalar_iload(old_cr->Opr()) && old_cr->Opr() != OPR_PARM)
00222       break;
00223     if (cr->Ilod_base() != old_cr->Ilod_base())
00224       changed = TRUE;
00225     if (cr->Opr() == OPR_MLOAD)
00226       if (cr->Mload_size() != old_cr->Mload_size())
00227         changed = TRUE;
00228     break;
00229   case CK_OP:
00230     if ((cr->Dtyp() != old_cr->Dtyp()) || (cr->Dsctyp() != old_cr->Dsctyp())) {
00231         changed = TRUE;
00232   break;
00233     }
00234     for (INT i = 0; i < old_cr->Kid_count(); i++)
00235       if (cr->Opnd(i) != old_cr->Opnd(i)) {
00236         changed = TRUE;
00237   break;
00238       }
00239     break;
00240   }
00241   if (changed) {
00242     old_cr->DecUsecnt();
00243     return htable->Rehash(cr); 
00244   }
00245   return old_cr;
00246 }
00247 
00248 CODEREP *
00249 U64_LOWER_create_cvtl(TYPE_ID res, CODEREP *x, INT cvtl_len) {
00250   CODEREP *stack_cr = Alloc_stack_cr(0); 
00251   stack_cr->Init_expr(OPCODE_make_op(OPR_CVTL, res, MTYPE_V), x);
00252   stack_cr->Set_offset(cvtl_len);
00253   return htable->Rehash(stack_cr);
00254 }
00255 
00256 CODEREP *
00257 U64_LOWER_create_ne_0(TYPE_ID res, TYPE_ID desc, CODEREP *x) {
00258   CODEREP *stack_cr = Alloc_stack_cr(1); 
00259   stack_cr->Init_expr(OPCODE_make_op(OPR_NE, res, desc), x);
00260   stack_cr->Set_opnd(1, htable->Add_const(desc, 0));
00261   return htable->Rehash(stack_cr);
00262 }
00263 
00264 /* ====================================================================
00265  * Insert a CVTL that has been delayed. hob_to_do gives the target signedness.
00266  * The CVTL is on Kid kidno of tree with size cvtl_bits.
00267  * hob_state provides hob info so the CVTL can be omitted if necessary.
00268  * Resulting hob info is returned in hob_state.
00269  * ==================================================================== */
00270 void 
00271 U64_LOWER_insert_cvtl_for_kid(CODEREP *x, HIGH_ORDER_BITS hob_to_do, INT kidno,
00272             INT cvtl_bits, HIGH_ORDER_BITS &hob_state)
00273 {
00274   if (cvtl_bits == 64)
00275     return;
00276   if (cvtl_bits == 0)
00277     return;
00278   if (hob_to_do == HOB_none)
00279     return;
00280   if (hob_to_do == hob_state)
00281     return;
00282 
00283   CODEREP *cr = U64_LOWER_create_cvtl(
00284           hob_to_do == HOB_sign_xtd ? MTYPE_I8 : MTYPE_U8,
00285           U64_LOWER_kid(x, kidno), cvtl_bits);
00286   U64_LOWER_set_kid(x, kidno, cr);
00287   hob_state = hob_to_do;
00288 }
00289 
00290 void
00291 U64_LOWER_insert_cvtl_for_kid(STMTREP *s, HIGH_ORDER_BITS hob_to_do, INT kidno,
00292                               INT cvtl_bits, HIGH_ORDER_BITS &hob_state)
00293 {
00294   if (cvtl_bits == 64)
00295     return;
00296   if (cvtl_bits == 0)
00297     return;
00298   if (hob_to_do == HOB_none)
00299     return;
00300   if (hob_to_do == hob_state)
00301     return;
00302 
00303   CODEREP *opnd;
00304   if (kidno == 0)
00305     opnd = s->Rhs();
00306   else if (kidno == 1)
00307     opnd = s->Lhs()->Istr_base();
00308   else opnd = s->Lhs()->Mstore_size();
00309 
00310   CODEREP *cr = U64_LOWER_create_cvtl(
00311           hob_to_do == HOB_sign_xtd ? MTYPE_I8 : MTYPE_U8,
00312           opnd, cvtl_bits);
00313   if (kidno == 0)
00314     s->Set_rhs(cr);
00315   else if (kidno == 1)
00316     s->Lhs()->Set_istr_base(cr);
00317   else s->Lhs()->Set_mstore_size(cr);
00318   hob_state = hob_to_do;
00319 }
00320 
00321 /* ====================================================================
00322  * End of specialized support routines 
00323  * ==================================================================== */
00324 
00325 
00326 /* ====================================================================
00327  * lower the given statement to zero-extended 64-bit target ISA.
00328  * ==================================================================== */
00329 void
00330 U64_lower_stmtrep(STMTREP *s, BOOL leave_CVTL_at_leaf)
00331 {
00332   INT maxsize;
00333   HIGH_ORDER_BITS hob_state, hob_to_do;
00334   OPERATOR opr = s->Opr();
00335   TYPE_ID desc = s->Desc();
00336   TYPE_ID res = s->Rtype();
00337   INT i;
00338 
00339   switch (opr) {
00340 
00341   // operators with no expression as kid
00342   case OPR_GOTO:
00343   case OPR_GOTO_OUTER_BLOCK:
00344   case OPR_RETURN:
00345   case OPR_COMMENT:
00346   case OPR_TRAP :
00347   case OPR_FORWARD_BARRIER:
00348   case OPR_BACKWARD_BARRIER:
00349   case OPR_ALTENTRY:
00350   case OPR_PRAGMA:
00351   case OPR_LABEL:
00352   case OPR_REGION:
00353   case OPR_REGION_EXIT:
00354   case OPR_BLOCK:
00355   case OPR_OPT_CHI:
00356     return;
00357 
00358   case OPR_DEALLOCA:  // only kid 0 contains node relevant to U64 lowering
00359     s->Rhs()->Set_opnd(0, U64_LOWER_expr(s->Rhs()->Opnd(0), maxsize, hob_state,
00360            hob_to_do, leave_CVTL_at_leaf));
00361     return;
00362 
00363   case OPR_PREFETCH:
00364     s->Rhs()->Set_ilod_base(U64_LOWER_expr(s->Rhs()->Ilod_base(), maxsize, 
00365         hob_state, hob_to_do, leave_CVTL_at_leaf));
00366     return;
00367 
00368   case OPR_AGOTO:
00369     // don't need to do anything
00370     s->Set_rhs(U64_LOWER_expr(s->Rhs(), maxsize, 
00371             hob_state, hob_to_do, leave_CVTL_at_leaf));
00372     return;
00373 
00374   case OPR_EVAL: 
00375     s->Set_rhs(U64_LOWER_expr(s->Rhs(), maxsize, 
00376             hob_state, hob_to_do, leave_CVTL_at_leaf));
00377     // need to set high-order bits because may become kid of LOOP_INFO
00378     U64_LOWER_insert_cvtl_for_kid(s, hob_to_do, 0, maxsize, hob_state);
00379     return;
00380 
00381   case OPR_TRUEBR:
00382   case OPR_FALSEBR:
00383   case OPR_ASSERT:
00384     s->Set_rhs(U64_LOWER_expr(s->Rhs(), maxsize, 
00385             hob_state, hob_to_do, leave_CVTL_at_leaf));
00386     if (maxsize != 0 && maxsize != 64) { // generate comparison with 0
00387       if (hob_state == HOB_none)  // enlarge Kid 0
00388   U64_LOWER_insert_cvtl_for_kid(s, HOB_zero_xtd, 0, maxsize, hob_state);
00389 #if 0
00390       s->Set_rhs(U64_LOWER_create_ne_0(Boolean_type, MTYPE_U8, s->Rhs()));
00391 #endif
00392     }
00393     return;
00394 
00395   case OPR_ISTORE:
00396     s->Lhs()->Set_istr_base(U64_LOWER_expr(s->Lhs()->Istr_base(), maxsize, 
00397             hob_state, hob_to_do, leave_CVTL_at_leaf));
00398   // fall through
00399 
00400   case OPR_STID:
00401     s->Set_rhs(U64_LOWER_expr(s->Rhs(), maxsize, 
00402             hob_state, hob_to_do, leave_CVTL_at_leaf));
00403     if (MTYPE_bit_size(desc) > maxsize) 
00404       U64_LOWER_insert_cvtl_for_kid(s, hob_to_do, 0, maxsize, hob_state);
00405     return;
00406 
00407   case OPR_ISTBITS:
00408     s->Lhs()->Set_istr_base(U64_LOWER_expr(s->Lhs()->Istr_base(), maxsize, 
00409             hob_state, hob_to_do, leave_CVTL_at_leaf));
00410     s->Set_rhs(U64_LOWER_expr(s->Rhs(), maxsize, 
00411             hob_state, hob_to_do, leave_CVTL_at_leaf));
00412     if (s->Lhs()->I_bit_size() > maxsize) 
00413       U64_LOWER_insert_cvtl_for_kid(s, hob_to_do, 0, maxsize, hob_state);
00414     return;
00415 
00416   case OPR_STBITS:
00417     s->Set_rhs(U64_LOWER_expr(s->Rhs(), maxsize, 
00418             hob_state, hob_to_do, leave_CVTL_at_leaf));
00419     if (s->Lhs()->Bit_size() > maxsize) 
00420       U64_LOWER_insert_cvtl_for_kid(s, hob_to_do, 0, maxsize, hob_state);
00421     return;
00422 
00423   case OPR_MSTORE:
00424     s->Lhs()->Set_mstore_size(U64_LOWER_expr(s->Lhs()->Mstore_size(), maxsize, 
00425             hob_state, hob_to_do, leave_CVTL_at_leaf));
00426     U64_LOWER_insert_cvtl_for_kid(s, hob_to_do, 2, maxsize, hob_state);
00427     s->Lhs()->Set_istr_base(U64_LOWER_expr(s->Lhs()->Istr_base(), maxsize, 
00428             hob_state, hob_to_do, leave_CVTL_at_leaf));
00429     s->Set_rhs(U64_LOWER_expr(s->Rhs(), maxsize, 
00430             hob_state, hob_to_do, leave_CVTL_at_leaf));
00431     return;
00432 
00433   case OPR_RETURN_VAL:
00434     s->Set_rhs(U64_LOWER_expr(s->Rhs(), maxsize, 
00435             hob_state, hob_to_do, leave_CVTL_at_leaf));
00436     if (MTYPE_bit_size(res) > maxsize)
00437       U64_LOWER_insert_cvtl_for_kid(s, hob_to_do, 0, maxsize, hob_state);
00438     return;
00439 
00440   case OPR_CALL:          
00441   case OPR_ICALL:
00442   case OPR_INTRINSIC_CALL:
00443     for (i = 0; i < s->Rhs()->Kid_count(); i++)
00444       s->Rhs()->Set_opnd(i, U64_LOWER_expr(s->Rhs()->Opnd(i), maxsize, 
00445            hob_state, hob_to_do, leave_CVTL_at_leaf));
00446     return;
00447 
00448   case OPR_ASM_STMT:
00449     for (i = 2; i < s->Rhs()->Kid_count(); i++)
00450       s->Rhs()->Opnd(i)->Set_opnd(0, U64_LOWER_expr(s->Rhs()->Opnd(i)->Opnd(0),
00451           maxsize, hob_state, hob_to_do, leave_CVTL_at_leaf));
00452     return;
00453 
00454   case OPR_COMPGOTO:
00455   case OPR_XGOTO:
00456     s->Set_rhs(U64_LOWER_expr(s->Rhs(), maxsize, 
00457             hob_state, hob_to_do, leave_CVTL_at_leaf));
00458     U64_LOWER_insert_cvtl_for_kid(s, HOB_zero_xtd, 0, maxsize, hob_state);
00459     return;
00460 
00461   case OPR_XPRAGMA:
00462     s->Set_rhs(U64_LOWER_expr(s->Rhs(), maxsize, 
00463            hob_state, hob_to_do, leave_CVTL_at_leaf));
00464     U64_LOWER_insert_cvtl_for_kid(s, hob_to_do, 0, maxsize, hob_state);
00465     return;
00466 
00467   default:  
00468     Is_True(FALSE,("unexpected operator"));
00469   }
00470 
00471   return;  
00472 }
00473 
00474 // ====================================================================
00475 // Top level routine for lowering to zero-extended 64-bit target ISA
00476 // for coderep.  The dtyp/dsctyp for CK_VAR, CK_IVAR and CK_CONST nodes
00477 // are changed only in a post-pass.
00478 // ==================================================================== 
00479 void
00480 COMP_UNIT::U64_lower_cr(BOOL leave_CVTL_at_leaf)
00481 {
00482   if ( Get_Trace(TP_GLOBOPT, OPT_LOWER_FLAG)) {
00483     fprintf( TFile, "%sBefore COMP_UNIT::U64_lower_cr\n%s",
00484              DBar, DBar );
00485     Cfg()->Print(TFile);
00486   }
00487 
00488   htable = Htable();  // initialize the file-scope static variable
00489 
00490   CFG_ITER cfg_iter(Cfg());
00491   BB_NODE *bb;
00492   FOR_ALL_NODE(bb, cfg_iter, Init()) {
00493     STMTREP_ITER stmt_iter(bb->Stmtlist());
00494     STMTREP *stmt;
00495     FOR_ALL_NODE(stmt, stmt_iter, Init()) 
00496       U64_lower_stmtrep(stmt, leave_CVTL_at_leaf);
00497   }
00498 
00499   // fix the dtyp/dsctyp for CK_VAR
00500   AUX_ID i;
00501   AUX_STAB_ITER aux_stab_iter(Opt_stab());
00502   CODEREP *cr;
00503   CODEREP_ITER cr_iter;
00504   FOR_ALL_NODE(i, aux_stab_iter, Init()) {
00505     AUX_STAB_ENTRY *aux = Opt_stab()->Aux_stab_entry(i);
00506     if (! aux->Is_real_var()) 
00507       continue;
00508     if (! (aux->Mclass() & MTYPE_CLASS_INTEGER))
00509       continue;
00510     if (ST_class(aux->St()) == CLASS_PREG) {
00511       FOR_ALL_NODE(cr, cr_iter, Init(aux->Cr_list())) {
00512   if (cr->Dtyp() != MTYPE_B)
00513           cr->Set_dtyp(Mtype_TransferSize(MTYPE_A8, cr->Dtyp()));
00514       }
00515     }
00516     else {
00517       FOR_ALL_NODE(cr, cr_iter, Init(aux->Cr_list())) {
00518   Is_True(cr->Dtyp() != MTYPE_B,
00519       ("COMP_UNIT::U64_lower_cr: non-preg var cannot have have MTYPE_B"));
00520         cr->Reset_sign_extd();
00521         if (MTYPE_signed(cr->Dsctyp())) 
00522     cr->Set_dsctyp(Mtype_TransferSign(MTYPE_U8, cr->Dsctyp()));
00523         cr->Set_dtyp(MTYPE_U8);
00524       }
00525     }
00526   }
00527 
00528   // fix the dtyp/dsctyp for CK_IVAR and CK_CONST nodes
00529   CODEREP *bucket;
00530   CODEMAP_ITER codemap_iter;
00531   FOR_ALL_ELEM(bucket, codemap_iter, Init(Htable())) {
00532     FOR_ALL_NODE(cr, cr_iter, Init(bucket)) {
00533       if (cr->Kind() == CK_CONST)
00534         cr->Set_dtyp_strictly(Mtype_TransferSize(MTYPE_A8, cr->Dtyp()));
00535       else if (cr->Kind() == CK_IVAR && cr->Opr() == OPR_ILOAD) {
00536   Is_True(cr->Dtyp() != MTYPE_B,
00537     ("COMP_UNIT::U64_lower_cr: non-preg ivar cannot have have MTYPE_B"));
00538   if (! MTYPE_is_integral(cr->Dtyp()))
00539     continue;
00540         cr->Reset_sign_extd();
00541         if (MTYPE_signed(cr->Dsctyp())) 
00542     cr->Set_dsctyp(Mtype_TransferSign(MTYPE_U8, cr->Dsctyp()));
00543         cr->Set_dtyp(MTYPE_U8);
00544       }
00545     }
00546   }
00547 
00548   if ( Get_Trace(TP_GLOBOPT, OPT_LOWER_FLAG)) {
00549     fprintf( TFile, "%sAfter COMP_UNIT::U64_lower_cr\n%s",
00550              DBar, DBar );
00551     Cfg()->Print(TFile);
00552   }
00553 }