Return to expr.c CVS log

Up to [Apple XNU] / GNUtools / cc

Annotation of GNUtools/cc/expr.c, revision 1.1

1.1     ! root        1: /* Convert tree expression to rtl instructions, for GNU compiler.
        !             2:    Copyright (C) 1988, 1992, 1993 Free Software Foundation, Inc.
        !             3: 
        !             4: This file is part of GNU CC.
        !             5: 
        !             6: GNU CC is free software; you can redistribute it and/or modify
        !             7: it under the terms of the GNU General Public License as published by
        !             8: the Free Software Foundation; either version 2, or (at your option)
        !             9: any later version.
        !            10: 
        !            11: GNU CC is distributed in the hope that it will be useful,
        !            12: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            14: GNU General Public License for more details.
        !            15: 
        !            16: You should have received a copy of the GNU General Public License
        !            17: along with GNU CC; see the file COPYING.  If not, write to
        !            18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
        !            19: 
        !            20: 
        !            21: #include "config.h"
        !            22: #include "machmode.h"
        !            23: #include "rtl.h"
        !            24: #include "tree.h"
        !            25: #include "obstack.h"
        !            26: #include "flags.h"
        !            27: #include "function.h"
        !            28: #include "insn-flags.h"
        !            29: #include "insn-codes.h"
        !            30: #include "expr.h"
        !            31: #include "insn-config.h"
        !            32: #include "recog.h"
        !            33: #include "output.h"
        !            34: #include "typeclass.h"
        !            35: 
        !            36: #include "bytecode.h"
        !            37: #include "bc-opcode.h"
        !            38: #include "bc-typecd.h"
        !            39: #include "bc-optab.h"
        !            40: #include "bc-emit.h"
        !            41: 
        !            42: 
        !            43: #define CEIL(x,y) (((x) + (y) - 1) / (y))
        !            44: 
        !            45: /* Decide whether a function's arguments should be processed
        !            46:    from first to last or from last to first.
        !            47: 
        !            48:    They should if the stack and args grow in opposite directions, but
        !            49:    only if we have push insns.  */
        !            50: 
        !            51: #ifdef PUSH_ROUNDING
        !            52: 
        !            53: #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)
        !            54: #define PUSH_ARGS_REVERSED     /* If it's last to first */
        !            55: #endif
        !            56: 
        !            57: #endif
        !            58: 
        !            59: #ifndef STACK_PUSH_CODE
        !            60: #ifdef STACK_GROWS_DOWNWARD
        !            61: #define STACK_PUSH_CODE PRE_DEC
        !            62: #else
        !            63: #define STACK_PUSH_CODE PRE_INC
        !            64: #endif
        !            65: #endif
        !            66: 
        !            67: /* Like STACK_BOUNDARY but in units of bytes, not bits.  */
        !            68: #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
        !            69: 
        !            70: /* If this is nonzero, we do not bother generating VOLATILE
        !            71:    around volatile memory references, and we are willing to
        !            72:    output indirect addresses.  If cse is to follow, we reject
        !            73:    indirect addresses so a useful potential cse is generated;
        !            74:    if it is used only once, instruction combination will produce
        !            75:    the same indirect address eventually.  */
        !            76: int cse_not_expected;
        !            77: 
        !            78: /* Nonzero to generate code for all the subroutines within an
        !            79:    expression before generating the upper levels of the expression.
        !            80:    Nowadays this is never zero.  */
        !            81: int do_preexpand_calls = 1;
        !            82: 
        !            83: /* Number of units that we should eventually pop off the stack.
        !            84:    These are the arguments to function calls that have already returned.  */
        !            85: int pending_stack_adjust;
        !            86: 
        !            87: /* Nonzero means stack pops must not be deferred, and deferred stack
        !            88:    pops must not be output.  It is nonzero inside a function call,
        !            89:    inside a conditional expression, inside a statement expression,
        !            90:    and in other cases as well.  */
        !            91: int inhibit_defer_pop;
        !            92: 
        !            93: /* A list of all cleanups which belong to the arguments of
        !            94:    function calls being expanded by expand_call.  */
        !            95: tree cleanups_this_call;
        !            96: 
        !            97: /* Nonzero means __builtin_saveregs has already been done in this function.
        !            98:    The value is the pseudoreg containing the value __builtin_saveregs
        !            99:    returned.  */
        !           100: static rtx saveregs_value;
        !           101: 
        !           102: /* Similarly for __builtin_apply_args.  */
        !           103: static rtx apply_args_value;
        !           104: 
        !           105: /* This structure is used by move_by_pieces to describe the move to
        !           106:    be performed.  */
        !           107: 
        !           108: struct move_by_pieces
        !           109: {
        !           110:   rtx to;
        !           111:   rtx to_addr;
        !           112:   int autinc_to;
        !           113:   int explicit_inc_to;
        !           114:   rtx from;
        !           115:   rtx from_addr;
        !           116:   int autinc_from;
        !           117:   int explicit_inc_from;
        !           118:   int len;
        !           119:   int offset;
        !           120:   int reverse;
        !           121: };
        !           122: 
        !           123: /* Used to generate bytecodes: keep track of size of local variables,
        !           124:    as well as depth of arithmetic stack. (Notice that variables are
        !           125:    stored on the machine's stack, not the arithmetic stack.) */
        !           126: 
        !           127: int local_vars_size;
        !           128: extern int stack_depth;
        !           129: extern int max_stack_depth;
        !           130: extern struct obstack permanent_obstack;
        !           131: 
        !           132: 
        !           133: static rtx enqueue_insn                PROTO((rtx, rtx));
        !           134: static int queued_subexp_p     PROTO((rtx));
        !           135: static void init_queue         PROTO((void));
        !           136: static void move_by_pieces     PROTO((rtx, rtx, int, int));
        !           137: static int move_by_pieces_ninsns PROTO((unsigned int, int));
        !           138: static void move_by_pieces_1   PROTO((rtx (*) (), enum machine_mode,
        !           139:                                       struct move_by_pieces *));
        !           140: static void group_insns                PROTO((rtx));
        !           141: static void store_constructor  PROTO((tree, rtx));
        !           142: static rtx store_field         PROTO((rtx, int, int, enum machine_mode, tree,
        !           143:                                       enum machine_mode, int, int, int));
        !           144: static tree save_noncopied_parts PROTO((tree, tree));
        !           145: static tree init_noncopied_parts PROTO((tree, tree));
        !           146: static int safe_from_p         PROTO((rtx, tree));
        !           147: static int fixed_type_p                PROTO((tree));
        !           148: static int get_pointer_alignment PROTO((tree, unsigned));
        !           149: static tree string_constant    PROTO((tree, tree *));
        !           150: static tree c_strlen           PROTO((tree));
        !           151: static rtx expand_builtin  PROTO((tree, rtx, rtx, enum machine_mode, int));
        !           152: static int apply_args_size     PROTO((void));
        !           153: static int apply_result_size   PROTO((void));
        !           154: static rtx result_vector       PROTO((int, rtx));
        !           155: static rtx expand_builtin_apply_args PROTO((void));
        !           156: static rtx expand_builtin_apply        PROTO((rtx, rtx, rtx));
        !           157: static void expand_builtin_return PROTO((rtx));
        !           158: static rtx expand_increment    PROTO((tree, int));
        !           159: rtx bc_expand_increment                PROTO((struct increment_operator *, tree));
        !           160: tree bc_runtime_type_code      PROTO((tree));
        !           161: rtx bc_allocate_local          PROTO((int, int));
        !           162: void bc_store_memory           PROTO((tree, tree));
        !           163: tree bc_expand_component_address PROTO((tree));
        !           164: tree bc_expand_address                 PROTO((tree));
        !           165: void bc_expand_constructor     PROTO((tree));
        !           166: void bc_adjust_stack           PROTO((int));
        !           167: tree bc_canonicalize_array_ref PROTO((tree));
        !           168: void bc_load_memory            PROTO((tree, tree));
        !           169: void bc_load_externaddr                PROTO((rtx));
        !           170: void bc_load_externaddr_id     PROTO((tree, int));
        !           171: void bc_load_localaddr         PROTO((rtx));
        !           172: void bc_load_parmaddr          PROTO((rtx));
        !           173: static void preexpand_calls    PROTO((tree));
        !           174: static void do_jump_by_parts_greater PROTO((tree, int, rtx, rtx));
        !           175: static void do_jump_by_parts_greater_rtx PROTO((enum machine_mode, int, rtx, rtx, rtx, rtx));
        !           176: static void do_jump_by_parts_equality PROTO((tree, rtx, rtx));
        !           177: static void do_jump_by_parts_equality_rtx PROTO((rtx, rtx, rtx));
        !           178: static void do_jump_for_compare        PROTO((rtx, rtx, rtx));
        !           179: static rtx compare             PROTO((tree, enum rtx_code, enum rtx_code));
        !           180: static rtx do_store_flag       PROTO((tree, rtx, enum machine_mode, int));
        !           181: 
        !           182: /* Record for each mode whether we can move a register directly to or
        !           183:    from an object of that mode in memory.  If we can't, we won't try
        !           184:    to use that mode directly when accessing a field of that mode.  */
        !           185: 
        !           186: static char direct_load[NUM_MACHINE_MODES];
        !           187: static char direct_store[NUM_MACHINE_MODES];
        !           188: 
        !           189: /* MOVE_RATIO is the number of move instructions that is better than
        !           190:    a block move.  */
        !           191: 
        !           192: #ifndef MOVE_RATIO
        !           193: #if defined (HAVE_movstrqi) || defined (HAVE_movstrhi) || defined (HAVE_movstrsi) || defined (HAVE_movstrdi) || defined (HAVE_movstrti)
        !           194: #define MOVE_RATIO 2
        !           195: #else
        !           196: /* A value of around 6 would minimize code size; infinity would minimize
        !           197:    execution time.  */
        !           198: #define MOVE_RATIO 15
        !           199: #endif
        !           200: #endif
        !           201: 
        !           202: /* This array records the insn_code of insns to perform block moves.  */
        !           203: enum insn_code movstr_optab[NUM_MACHINE_MODES];
        !           204: 
        !           205: /* SLOW_UNALIGNED_ACCESS is non-zero if unaligned accesses are very slow. */
        !           206: 
        !           207: #ifndef SLOW_UNALIGNED_ACCESS
        !           208: #define SLOW_UNALIGNED_ACCESS 0
        !           209: #endif
        !           210: 
        !           211: /* Register mappings for target machines without register windows.  */
        !           212: #ifndef INCOMING_REGNO
        !           213: #define INCOMING_REGNO(OUT) (OUT)
        !           214: #endif
        !           215: #ifndef OUTGOING_REGNO
        !           216: #define OUTGOING_REGNO(IN) (IN)
        !           217: #endif
        !           218: 
        !           219: /* Maps used to convert modes to const, load, and store bytecodes. */
        !           220: enum bytecode_opcode mode_to_const_map[MAX_MACHINE_MODE];
        !           221: enum bytecode_opcode mode_to_load_map[MAX_MACHINE_MODE];
        !           222: enum bytecode_opcode mode_to_store_map[MAX_MACHINE_MODE];
        !           223: 
        !           224: /* Initialize maps used to convert modes to const, load, and store
        !           225:    bytecodes. */
        !           226: void
        !           227: bc_init_mode_to_opcode_maps ()
        !           228: {
        !           229:   int mode;
        !           230: 
        !           231:   for (mode = 0; mode < (int) MAX_MACHINE_MODE; mode++)
        !           232:     mode_to_const_map[mode] =
        !           233:       mode_to_load_map[mode] =
        !           234:        mode_to_store_map[mode] = neverneverland;
        !           235:       
        !           236: #define DEF_MODEMAP(SYM, CODE, UCODE, CONST, LOAD, STORE) \
        !           237:   mode_to_const_map[(int) SYM] = CONST; \
        !           238:   mode_to_load_map[(int) SYM] = LOAD; \
        !           239:   mode_to_store_map[(int) SYM] = STORE;
        !           240: 
        !           241: #include "modemap.def"
        !           242: #undef DEF_MODEMAP
        !           243: }
        !           244: 
        !           245: /* This is run once per compilation to set up which modes can be used
        !           246:    directly in memory and to initialize the block move optab.  */
        !           247: 
        !           248: void
        !           249: init_expr_once ()
        !           250: {
        !           251:   rtx insn, pat;
        !           252:   enum machine_mode mode;
        !           253:   /* Try indexing by frame ptr and try by stack ptr.
        !           254:      It is known that on the Convex the stack ptr isn't a valid index.
        !           255:      With luck, one or the other is valid on any machine.  */
        !           256:   rtx mem = gen_rtx (MEM, VOIDmode, stack_pointer_rtx);
        !           257:   rtx mem1 = gen_rtx (MEM, VOIDmode, frame_pointer_rtx);
        !           258: 
        !           259:   start_sequence ();
        !           260:   insn = emit_insn (gen_rtx (SET, 0, 0));
        !           261:   pat = PATTERN (insn);
        !           262: 
        !           263:   for (mode = VOIDmode; (int) mode < NUM_MACHINE_MODES;
        !           264:        mode = (enum machine_mode) ((int) mode + 1))
        !           265:     {
        !           266:       int regno;
        !           267:       rtx reg;
        !           268:       int num_clobbers;
        !           269: 
        !           270:       direct_load[(int) mode] = direct_store[(int) mode] = 0;
        !           271:       PUT_MODE (mem, mode);
        !           272:       PUT_MODE (mem1, mode);
        !           273: 
        !           274:       /* See if there is some register that can be used in this mode and
        !           275:         directly loaded or stored from memory.  */
        !           276: 
        !           277:       if (mode != VOIDmode && mode != BLKmode)
        !           278:        for (regno = 0; regno < FIRST_PSEUDO_REGISTER
        !           279:             && (direct_load[(int) mode] == 0 || direct_store[(int) mode] == 0);
        !           280:             regno++)
        !           281:          {
        !           282:            if (! HARD_REGNO_MODE_OK (regno, mode))
        !           283:              continue;
        !           284: 
        !           285:            reg = gen_rtx (REG, mode, regno);
        !           286: 
        !           287:            SET_SRC (pat) = mem;
        !           288:            SET_DEST (pat) = reg;
        !           289:            if (recog (pat, insn, &num_clobbers) >= 0)
        !           290:              direct_load[(int) mode] = 1;
        !           291: 
        !           292:            SET_SRC (pat) = mem1;
        !           293:            SET_DEST (pat) = reg;
        !           294:            if (recog (pat, insn, &num_clobbers) >= 0)
        !           295:              direct_load[(int) mode] = 1;
        !           296: 
        !           297:            SET_SRC (pat) = reg;
        !           298:            SET_DEST (pat) = mem;
        !           299:            if (recog (pat, insn, &num_clobbers) >= 0)
        !           300:              direct_store[(int) mode] = 1;
        !           301: 
        !           302:            SET_SRC (pat) = reg;
        !           303:            SET_DEST (pat) = mem1;
        !           304:            if (recog (pat, insn, &num_clobbers) >= 0)
        !           305:              direct_store[(int) mode] = 1;
        !           306:          }
        !           307:     }
        !           308: 
        !           309:   end_sequence ();
        !           310: }
        !           311:       
        !           312: /* This is run at the start of compiling a function.  */
        !           313: 
        !           314: void
        !           315: init_expr ()
        !           316: {
        !           317:   init_queue ();
        !           318: 
        !           319:   pending_stack_adjust = 0;
        !           320:   inhibit_defer_pop = 0;
        !           321:   cleanups_this_call = 0;
        !           322:   saveregs_value = 0;
        !           323:   apply_args_value = 0;
        !           324:   forced_labels = 0;
        !           325: }
        !           326: 
        !           327: /* Save all variables describing the current status into the structure *P.
        !           328:    This is used before starting a nested function.  */
        !           329: 
        !           330: void
        !           331: save_expr_status (p)
        !           332:      struct function *p;
        !           333: {
        !           334:   /* Instead of saving the postincrement queue, empty it.  */
        !           335:   emit_queue ();
        !           336: 
        !           337:   p->pending_stack_adjust = pending_stack_adjust;
        !           338:   p->inhibit_defer_pop = inhibit_defer_pop;
        !           339:   p->cleanups_this_call = cleanups_this_call;
        !           340:   p->saveregs_value = saveregs_value;
        !           341:   p->apply_args_value = apply_args_value;
        !           342:   p->forced_labels = forced_labels;
        !           343: 
        !           344:   pending_stack_adjust = 0;
        !           345:   inhibit_defer_pop = 0;
        !           346:   cleanups_this_call = 0;
        !           347:   saveregs_value = 0;
        !           348:   apply_args_value = 0;
        !           349:   forced_labels = 0;
        !           350: }
        !           351: 
        !           352: /* Restore all variables describing the current status from the structure *P.
        !           353:    This is used after a nested function.  */
        !           354: 
        !           355: void
        !           356: restore_expr_status (p)
        !           357:      struct function *p;
        !           358: {
        !           359:   pending_stack_adjust = p->pending_stack_adjust;
        !           360:   inhibit_defer_pop = p->inhibit_defer_pop;
        !           361:   cleanups_this_call = p->cleanups_this_call;
        !           362:   saveregs_value = p->saveregs_value;
        !           363:   apply_args_value = p->apply_args_value;
        !           364:   forced_labels = p->forced_labels;
        !           365: }
        !           366: 
        !           367: /* Manage the queue of increment instructions to be output
        !           368:    for POSTINCREMENT_EXPR expressions, etc.  */
        !           369: 
        !           370: static rtx pending_chain;
        !           371: 
        !           372: /* Queue up to increment (or change) VAR later.  BODY says how:
        !           373:    BODY should be the same thing you would pass to emit_insn
        !           374:    to increment right away.  It will go to emit_insn later on.
        !           375: 
        !           376:    The value is a QUEUED expression to be used in place of VAR
        !           377:    where you want to guarantee the pre-incrementation value of VAR.  */
        !           378: 
        !           379: static rtx
        !           380: enqueue_insn (var, body)
        !           381:      rtx var, body;
        !           382: {
        !           383:   pending_chain = gen_rtx (QUEUED, GET_MODE (var),
        !           384:                           var, NULL_RTX, NULL_RTX, body, pending_chain);
        !           385:   return pending_chain;
        !           386: }
        !           387: 
        !           388: /* Use protect_from_queue to convert a QUEUED expression
        !           389:    into something that you can put immediately into an instruction.
        !           390:    If the queued incrementation has not happened yet,
        !           391:    protect_from_queue returns the variable itself.
        !           392:    If the incrementation has happened, protect_from_queue returns a temp
        !           393:    that contains a copy of the old value of the variable.
        !           394: 
        !           395:    Any time an rtx which might possibly be a QUEUED is to be put
        !           396:    into an instruction, it must be passed through protect_from_queue first.
        !           397:    QUEUED expressions are not meaningful in instructions.
        !           398: 
        !           399:    Do not pass a value through protect_from_queue and then hold
        !           400:    on to it for a while before putting it in an instruction!
        !           401:    If the queue is flushed in between, incorrect code will result.  */
        !           402: 
        !           403: rtx
        !           404: protect_from_queue (x, modify)
        !           405:      register rtx x;
        !           406:      int modify;
        !           407: {
        !           408:   register RTX_CODE code = GET_CODE (x);
        !           409: 
        !           410: #if 0  /* A QUEUED can hang around after the queue is forced out.  */
        !           411:   /* Shortcut for most common case.  */
        !           412:   if (pending_chain == 0)
        !           413:     return x;
        !           414: #endif
        !           415: 
        !           416:   if (code != QUEUED)
        !           417:     {
        !           418:       /* A special hack for read access to (MEM (QUEUED ...))
        !           419:         to facilitate use of autoincrement.
        !           420:         Make a copy of the contents of the memory location
        !           421:         rather than a copy of the address, but not
        !           422:         if the value is of mode BLKmode.  */
        !           423:       if (code == MEM && GET_MODE (x) != BLKmode
        !           424:          && GET_CODE (XEXP (x, 0)) == QUEUED && !modify)
        !           425:        {
        !           426:          register rtx y = XEXP (x, 0);
        !           427:          XEXP (x, 0) = QUEUED_VAR (y);
        !           428:          if (QUEUED_INSN (y))
        !           429:            {
        !           430:              register rtx temp = gen_reg_rtx (GET_MODE (x));
        !           431:              emit_insn_before (gen_move_insn (temp, x),
        !           432:                                QUEUED_INSN (y));
        !           433:              return temp;
        !           434:            }
        !           435:          return x;
        !           436:        }
        !           437:       /* Otherwise, recursively protect the subexpressions of all
        !           438:         the kinds of rtx's that can contain a QUEUED.  */
        !           439:       if (code == MEM)
        !           440:        {
        !           441:          rtx tem = protect_from_queue (XEXP (x, 0), 0);
        !           442:          if (tem != XEXP (x, 0))
        !           443:            {
        !           444:              x = copy_rtx (x);
        !           445:              XEXP (x, 0) = tem;
        !           446:            }
        !           447:        }
        !           448:       else if (code == PLUS || code == MULT)
        !           449:        {
        !           450:          rtx new0 = protect_from_queue (XEXP (x, 0), 0);
        !           451:          rtx new1 = protect_from_queue (XEXP (x, 1), 0);
        !           452:          if (new0 != XEXP (x, 0) || new1 != XEXP (x, 1))
        !           453:            {
        !           454:              x = copy_rtx (x);
        !           455:              XEXP (x, 0) = new0;
        !           456:              XEXP (x, 1) = new1;
        !           457:            }
        !           458:        }
        !           459:       return x;
        !           460:     }
        !           461:   /* If the increment has not happened, use the variable itself.  */
        !           462:   if (QUEUED_INSN (x) == 0)
        !           463:     return QUEUED_VAR (x);
        !           464:   /* If the increment has happened and a pre-increment copy exists,
        !           465:      use that copy.  */
        !           466:   if (QUEUED_COPY (x) != 0)
        !           467:     return QUEUED_COPY (x);
        !           468:   /* The increment has happened but we haven't set up a pre-increment copy.
        !           469:      Set one up now, and use it.  */
        !           470:   QUEUED_COPY (x) = gen_reg_rtx (GET_MODE (QUEUED_VAR (x)));
        !           471:   emit_insn_before (gen_move_insn (QUEUED_COPY (x), QUEUED_VAR (x)),
        !           472:                    QUEUED_INSN (x));
        !           473:   return QUEUED_COPY (x);
        !           474: }
        !           475: 
        !           476: /* Return nonzero if X contains a QUEUED expression:
        !           477:    if it contains anything that will be altered by a queued increment.
        !           478:    We handle only combinations of MEM, PLUS, MINUS and MULT operators
        !           479:    since memory addresses generally contain only those.  */
        !           480: 
        !           481: static int
        !           482: queued_subexp_p (x)
        !           483:      rtx x;
        !           484: {
        !           485:   register enum rtx_code code = GET_CODE (x);
        !           486:   switch (code)
        !           487:     {
        !           488:     case QUEUED:
        !           489:       return 1;
        !           490:     case MEM:
        !           491:       return queued_subexp_p (XEXP (x, 0));
        !           492:     case MULT:
        !           493:     case PLUS:
        !           494:     case MINUS:
        !           495:       return queued_subexp_p (XEXP (x, 0))
        !           496:        || queued_subexp_p (XEXP (x, 1));
        !           497:     }
        !           498:   return 0;
        !           499: }
        !           500: 
        !           501: /* Perform all the pending incrementations.  */
        !           502: 
        !           503: void
        !           504: emit_queue ()
        !           505: {
        !           506:   register rtx p;
        !           507:   while (p = pending_chain)
        !           508:     {
        !           509:       QUEUED_INSN (p) = emit_insn (QUEUED_BODY (p));
        !           510:       pending_chain = QUEUED_NEXT (p);
        !           511:     }
        !           512: }
        !           513: 
        !           514: static void
        !           515: init_queue ()
        !           516: {
        !           517:   if (pending_chain)
        !           518:     abort ();
        !           519: }
        !           520: 
        !           521: /* Copy data from FROM to TO, where the machine modes are not the same.
        !           522:    Both modes may be integer, or both may be floating.
        !           523:    UNSIGNEDP should be nonzero if FROM is an unsigned type.
        !           524:    This causes zero-extension instead of sign-extension.  */
        !           525: 
        !           526: void
        !           527: convert_move (to, from, unsignedp)
        !           528:      register rtx to, from;
        !           529:      int unsignedp;
        !           530: {
        !           531:   enum machine_mode to_mode = GET_MODE (to);
        !           532:   enum machine_mode from_mode = GET_MODE (from);
        !           533:   int to_real = GET_MODE_CLASS (to_mode) == MODE_FLOAT;
        !           534:   int from_real = GET_MODE_CLASS (from_mode) == MODE_FLOAT;
        !           535:   enum insn_code code;
        !           536:   rtx libcall;
        !           537: 
        !           538:   /* rtx code for making an equivalent value.  */
        !           539:   enum rtx_code equiv_code = (unsignedp ? ZERO_EXTEND : SIGN_EXTEND);
        !           540: 
        !           541:   to = protect_from_queue (to, 1);
        !           542:   from = protect_from_queue (from, 0);
        !           543: 
        !           544:   if (to_real != from_real)
        !           545:     abort ();
        !           546: 
        !           547:   /* If FROM is a SUBREG that indicates that we have already done at least
        !           548:      the required extension, strip it.  We don't handle such SUBREGs as
        !           549:      TO here.  */
        !           550: 
        !           551:   if (GET_CODE (from) == SUBREG && SUBREG_PROMOTED_VAR_P (from)
        !           552:       && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (from)))
        !           553:          >= GET_MODE_SIZE (to_mode))
        !           554:       && SUBREG_PROMOTED_UNSIGNED_P (from) == unsignedp)
        !           555:     from = gen_lowpart (to_mode, from), from_mode = to_mode;
        !           556: 
        !           557:   if (GET_CODE (to) == SUBREG && SUBREG_PROMOTED_VAR_P (to))
        !           558:     abort ();
        !           559: 
        !           560:   if (to_mode == from_mode
        !           561:       || (from_mode == VOIDmode && CONSTANT_P (from)))
        !           562:     {
        !           563:       emit_move_insn (to, from);
        !           564:       return;
        !           565:     }
        !           566: 
        !           567:   if (to_real)
        !           568:     {
        !           569:       rtx value;
        !           570: 
        !           571: #ifdef HAVE_extendqfhf2
        !           572:       if (HAVE_extendqfsf2 && from_mode == QFmode && to_mode == HFmode)
        !           573:        {
        !           574:          emit_unop_insn (CODE_FOR_extendqfsf2, to, from, UNKNOWN);
        !           575:          return;
        !           576:        }
        !           577: #endif
        !           578: #ifdef HAVE_extendqfsf2
        !           579:       if (HAVE_extendqfsf2 && from_mode == QFmode && to_mode == SFmode)
        !           580:        {
        !           581:          emit_unop_insn (CODE_FOR_extendqfsf2, to, from, UNKNOWN);
        !           582:          return;
        !           583:        }
        !           584: #endif
        !           585: #ifdef HAVE_extendqfdf2
        !           586:       if (HAVE_extendqfdf2 && from_mode == QFmode && to_mode == DFmode)
        !           587:        {
        !           588:          emit_unop_insn (CODE_FOR_extendqfdf2, to, from, UNKNOWN);
        !           589:          return;
        !           590:        }
        !           591: #endif
        !           592: #ifdef HAVE_extendqfxf2
        !           593:       if (HAVE_extendqfxf2 && from_mode == QFmode && to_mode == XFmode)
        !           594:        {
        !           595:          emit_unop_insn (CODE_FOR_extendqfxf2, to, from, UNKNOWN);
        !           596:          return;
        !           597:        }
        !           598: #endif
        !           599: #ifdef HAVE_extendqftf2
        !           600:       if (HAVE_extendqftf2 && from_mode == QFmode && to_mode == TFmode)
        !           601:        {
        !           602:          emit_unop_insn (CODE_FOR_extendqftf2, to, from, UNKNOWN);
        !           603:          return;
        !           604:        }
        !           605: #endif
        !           606: 
        !           607: #ifdef HAVE_extendhfsf2
        !           608:       if (HAVE_extendhfsf2 && from_mode == HFmode && to_mode == SFmode)
        !           609:        {
        !           610:          emit_unop_insn (CODE_FOR_extendhfsf2, to, from, UNKNOWN);
        !           611:          return;
        !           612:        }
        !           613: #endif
        !           614: #ifdef HAVE_extendhfdf2
        !           615:       if (HAVE_extendhfdf2 && from_mode == HFmode && to_mode == DFmode)
        !           616:        {
        !           617:          emit_unop_insn (CODE_FOR_extendhfdf2, to, from, UNKNOWN);
        !           618:          return;
        !           619:        }
        !           620: #endif
        !           621: #ifdef HAVE_extendhfxf2
        !           622:       if (HAVE_extendhfxf2 && from_mode == HFmode && to_mode == XFmode)
        !           623:        {
        !           624:          emit_unop_insn (CODE_FOR_extendhfxf2, to, from, UNKNOWN);
        !           625:          return;
        !           626:        }
        !           627: #endif
        !           628: #ifdef HAVE_extendhftf2
        !           629:       if (HAVE_extendhftf2 && from_mode == HFmode && to_mode == TFmode)
        !           630:        {
        !           631:          emit_unop_insn (CODE_FOR_extendhftf2, to, from, UNKNOWN);
        !           632:          return;
        !           633:        }
        !           634: #endif
        !           635: 
        !           636: #ifdef HAVE_extendsfdf2
        !           637:       if (HAVE_extendsfdf2 && from_mode == SFmode && to_mode == DFmode)
        !           638:        {
        !           639:          emit_unop_insn (CODE_FOR_extendsfdf2, to, from, UNKNOWN);
        !           640:          return;
        !           641:        }
        !           642: #endif
        !           643: #ifdef HAVE_extendsfxf2
        !           644:       if (HAVE_extendsfxf2 && from_mode == SFmode && to_mode == XFmode)
        !           645:        {
        !           646:          emit_unop_insn (CODE_FOR_extendsfxf2, to, from, UNKNOWN);
        !           647:          return;
        !           648:        }
        !           649: #endif
        !           650: #ifdef HAVE_extendsftf2
        !           651:       if (HAVE_extendsftf2 && from_mode == SFmode && to_mode == TFmode)
        !           652:        {
        !           653:          emit_unop_insn (CODE_FOR_extendsftf2, to, from, UNKNOWN);
        !           654:          return;
        !           655:        }
        !           656: #endif
        !           657: #ifdef HAVE_extenddfxf2
        !           658:       if (HAVE_extenddfxf2 && from_mode == DFmode && to_mode == XFmode)
        !           659:        {
        !           660:          emit_unop_insn (CODE_FOR_extenddfxf2, to, from, UNKNOWN);
        !           661:          return;
        !           662:        }
        !           663: #endif
        !           664: #ifdef HAVE_extenddftf2
        !           665:       if (HAVE_extenddftf2 && from_mode == DFmode && to_mode == TFmode)
        !           666:        {
        !           667:          emit_unop_insn (CODE_FOR_extenddftf2, to, from, UNKNOWN);
        !           668:          return;
        !           669:        }
        !           670: #endif
        !           671: 
        !           672: #ifdef HAVE_trunchfqf2
        !           673:       if (HAVE_trunchfqf2 && from_mode == HFmode && to_mode == QFmode)
        !           674:        {
        !           675:          emit_unop_insn (CODE_FOR_trunchfqf2, to, from, UNKNOWN);
        !           676:          return;
        !           677:        }
        !           678: #endif
        !           679: #ifdef HAVE_truncsfqf2
        !           680:       if (HAVE_truncsfqf2 && from_mode == SFmode && to_mode == QFmode)
        !           681:        {
        !           682:          emit_unop_insn (CODE_FOR_truncsfqf2, to, from, UNKNOWN);
        !           683:          return;
        !           684:        }
        !           685: #endif
        !           686: #ifdef HAVE_truncdfqf2
        !           687:       if (HAVE_truncdfqf2 && from_mode == DFmode && to_mode == QFmode)
        !           688:        {
        !           689:          emit_unop_insn (CODE_FOR_truncdfqf2, to, from, UNKNOWN);
        !           690:          return;
        !           691:        }
        !           692: #endif
        !           693: #ifdef HAVE_truncxfqf2
        !           694:       if (HAVE_truncxfqf2 && from_mode == XFmode && to_mode == QFmode)
        !           695:        {
        !           696:          emit_unop_insn (CODE_FOR_truncxfqf2, to, from, UNKNOWN);
        !           697:          return;
        !           698:        }
        !           699: #endif
        !           700: #ifdef HAVE_trunctfqf2
        !           701:       if (HAVE_trunctfqf2 && from_mode == TFmode && to_mode == QFmode)
        !           702:        {
        !           703:          emit_unop_insn (CODE_FOR_trunctfqf2, to, from, UNKNOWN);
        !           704:          return;
        !           705:        }
        !           706: #endif
        !           707: #ifdef HAVE_truncsfhf2
        !           708:       if (HAVE_truncsfhf2 && from_mode == SFmode && to_mode == HFmode)
        !           709:        {
        !           710:          emit_unop_insn (CODE_FOR_truncsfhf2, to, from, UNKNOWN);
        !           711:          return;
        !           712:        }
        !           713: #endif
        !           714: #ifdef HAVE_truncdfhf2
        !           715:       if (HAVE_truncdfhf2 && from_mode == DFmode && to_mode == HFmode)
        !           716:        {
        !           717:          emit_unop_insn (CODE_FOR_truncdfhf2, to, from, UNKNOWN);
        !           718:          return;
        !           719:        }
        !           720: #endif
        !           721: #ifdef HAVE_truncxfhf2
        !           722:       if (HAVE_truncxfhf2 && from_mode == XFmode && to_mode == HFmode)
        !           723:        {
        !           724:          emit_unop_insn (CODE_FOR_truncxfhf2, to, from, UNKNOWN);
        !           725:          return;
        !           726:        }
        !           727: #endif
        !           728: #ifdef HAVE_trunctfhf2
        !           729:       if (HAVE_trunctfhf2 && from_mode == TFmode && to_mode == HFmode)
        !           730:        {
        !           731:          emit_unop_insn (CODE_FOR_trunctfhf2, to, from, UNKNOWN);
        !           732:          return;
        !           733:        }
        !           734: #endif
        !           735: #ifdef HAVE_truncdfsf2
        !           736:       if (HAVE_truncdfsf2 && from_mode == DFmode && to_mode == SFmode)
        !           737:        {
        !           738:          emit_unop_insn (CODE_FOR_truncdfsf2, to, from, UNKNOWN);
        !           739:          return;
        !           740:        }
        !           741: #endif
        !           742: #ifdef HAVE_truncxfsf2
        !           743:       if (HAVE_truncxfsf2 && from_mode == XFmode && to_mode == SFmode)
        !           744:        {
        !           745:          emit_unop_insn (CODE_FOR_truncxfsf2, to, from, UNKNOWN);
        !           746:          return;
        !           747:        }
        !           748: #endif
        !           749: #ifdef HAVE_trunctfsf2
        !           750:       if (HAVE_trunctfsf2 && from_mode == TFmode && to_mode == SFmode)
        !           751:        {
        !           752:          emit_unop_insn (CODE_FOR_trunctfsf2, to, from, UNKNOWN);
        !           753:          return;
        !           754:        }
        !           755: #endif
        !           756: #ifdef HAVE_truncxfdf2
        !           757:       if (HAVE_truncxfdf2 && from_mode == XFmode && to_mode == DFmode)
        !           758:        {
        !           759:          emit_unop_insn (CODE_FOR_truncxfdf2, to, from, UNKNOWN);
        !           760:          return;
        !           761:        }
        !           762: #endif
        !           763: #ifdef HAVE_trunctfdf2
        !           764:       if (HAVE_trunctfdf2 && from_mode == TFmode && to_mode == DFmode)
        !           765:        {
        !           766:          emit_unop_insn (CODE_FOR_trunctfdf2, to, from, UNKNOWN);
        !           767:          return;
        !           768:        }
        !           769: #endif
        !           770: 
        !           771:       libcall = (rtx) 0;
        !           772:       switch (from_mode)
        !           773:        {
        !           774:        case SFmode:
        !           775:          switch (to_mode)
        !           776:            {
        !           777:            case DFmode:
        !           778:              libcall = extendsfdf2_libfunc;
        !           779:              break;
        !           780: 
        !           781:            case XFmode:
        !           782:              libcall = extendsfxf2_libfunc;
        !           783:              break;
        !           784: 
        !           785:            case TFmode:
        !           786:              libcall = extendsftf2_libfunc;
        !           787:              break;
        !           788:            }
        !           789:          break;
        !           790: 
        !           791:        case DFmode:
        !           792:          switch (to_mode)
        !           793:            {
        !           794:            case SFmode:
        !           795:              libcall = truncdfsf2_libfunc;
        !           796:              break;
        !           797: 
        !           798:            case XFmode:
        !           799:              libcall = extenddfxf2_libfunc;
        !           800:              break;
        !           801: 
        !           802:            case TFmode:
        !           803:              libcall = extenddftf2_libfunc;
        !           804:              break;
        !           805:            }
        !           806:          break;
        !           807: 
        !           808:        case XFmode:
        !           809:          switch (to_mode)
        !           810:            {
        !           811:            case SFmode:
        !           812:              libcall = truncxfsf2_libfunc;
        !           813:              break;
        !           814: 
        !           815:            case DFmode:
        !           816:              libcall = truncxfdf2_libfunc;
        !           817:              break;
        !           818:            }
        !           819:          break;
        !           820: 
        !           821:        case TFmode:
        !           822:          switch (to_mode)
        !           823:            {
        !           824:            case SFmode:
        !           825:              libcall = trunctfsf2_libfunc;
        !           826:              break;
        !           827: 
        !           828:            case DFmode:
        !           829:              libcall = trunctfdf2_libfunc;
        !           830:              break;
        !           831:            }
        !           832:          break;
        !           833:        }
        !           834: 
        !           835:       if (libcall == (rtx) 0)
        !           836:        /* This conversion is not implemented yet.  */
        !           837:        abort ();
        !           838: 
        !           839:       value = emit_library_call_value (libcall, NULL_RTX, 1, to_mode,
        !           840:                                       1, from, from_mode);
        !           841:       emit_move_insn (to, value);
        !           842:       return;
        !           843:     }
        !           844: 
        !           845:   /* Now both modes are integers.  */
        !           846: 
        !           847:   /* Handle expanding beyond a word.  */
        !           848:   if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode)
        !           849:       && GET_MODE_BITSIZE (to_mode) > BITS_PER_WORD)
        !           850:     {
        !           851:       rtx insns;
        !           852:       rtx lowpart;
        !           853:       rtx fill_value;
        !           854:       rtx lowfrom;
        !           855:       int i;
        !           856:       enum machine_mode lowpart_mode;
        !           857:       int nwords = CEIL (GET_MODE_SIZE (to_mode), UNITS_PER_WORD);
        !           858: 
        !           859:       /* Try converting directly if the insn is supported.  */
        !           860:       if ((code = can_extend_p (to_mode, from_mode, unsignedp))
        !           861:          != CODE_FOR_nothing)
        !           862:        {
        !           863:          /* If FROM is a SUBREG, put it into a register.  Do this
        !           864:             so that we always generate the same set of insns for
        !           865:             better cse'ing; if an intermediate assignment occurred,
        !           866:             we won't be doing the operation directly on the SUBREG.  */
        !           867:          if (optimize > 0 && GET_CODE (from) == SUBREG)
        !           868:            from = force_reg (from_mode, from);
        !           869:          emit_unop_insn (code, to, from, equiv_code);
        !           870:          return;
        !           871:        }
        !           872:       /* Next, try converting via full word.  */
        !           873:       else if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD
        !           874:               && ((code = can_extend_p (to_mode, word_mode, unsignedp))
        !           875:                   != CODE_FOR_nothing))
        !           876:        {
        !           877:          if (GET_CODE (to) == REG)
        !           878:            emit_insn (gen_rtx (CLOBBER, VOIDmode, to));
        !           879:          convert_move (gen_lowpart (word_mode, to), from, unsignedp);
        !           880:          emit_unop_insn (code, to,
        !           881:                          gen_lowpart (word_mode, to), equiv_code);
        !           882:          return;
        !           883:        }
        !           884: 
        !           885:       /* No special multiword conversion insn; do it by hand.  */
        !           886:       start_sequence ();
        !           887: 
        !           888:       /* Get a copy of FROM widened to a word, if necessary.  */
        !           889:       if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD)
        !           890:        lowpart_mode = word_mode;
        !           891:       else
        !           892:        lowpart_mode = from_mode;
        !           893: 
        !           894:       lowfrom = convert_to_mode (lowpart_mode, from, unsignedp);
        !           895: 
        !           896:       lowpart = gen_lowpart (lowpart_mode, to);
        !           897:       emit_move_insn (lowpart, lowfrom);
        !           898: 
        !           899:       /* Compute the value to put in each remaining word.  */
        !           900:       if (unsignedp)
        !           901:        fill_value = const0_rtx;
        !           902:       else
        !           903:        {
        !           904: #ifdef HAVE_slt
        !           905:          if (HAVE_slt
        !           906:              && insn_operand_mode[(int) CODE_FOR_slt][0] == word_mode
        !           907:              && STORE_FLAG_VALUE == -1)
        !           908:            {
        !           909:              emit_cmp_insn (lowfrom, const0_rtx, NE, NULL_RTX,
        !           910:                             lowpart_mode, 0, 0);
        !           911:              fill_value = gen_reg_rtx (word_mode);
        !           912:              emit_insn (gen_slt (fill_value));
        !           913:            }
        !           914:          else
        !           915: #endif
        !           916:            {
        !           917:              fill_value
        !           918:                = expand_shift (RSHIFT_EXPR, lowpart_mode, lowfrom,
        !           919:                                size_int (GET_MODE_BITSIZE (lowpart_mode) - 1),
        !           920:                                NULL_RTX, 0);
        !           921:              fill_value = convert_to_mode (word_mode, fill_value, 1);
        !           922:            }
        !           923:        }
        !           924: 
        !           925:       /* Fill the remaining words.  */
        !           926:       for (i = GET_MODE_SIZE (lowpart_mode) / UNITS_PER_WORD; i < nwords; i++)
        !           927:        {
        !           928:          int index = (WORDS_BIG_ENDIAN ? nwords - i - 1 : i);
        !           929:          rtx subword = operand_subword (to, index, 1, to_mode);
        !           930: 
        !           931:          if (subword == 0)
        !           932:            abort ();
        !           933: 
        !           934:          if (fill_value != subword)
        !           935:            emit_move_insn (subword, fill_value);
        !           936:        }
        !           937: 
        !           938:       insns = get_insns ();
        !           939:       end_sequence ();
        !           940: 
        !           941:       emit_no_conflict_block (insns, to, from, NULL_RTX,
        !           942:                              gen_rtx (equiv_code, to_mode, copy_rtx (from)));
        !           943:       return;
        !           944:     }
        !           945: 
        !           946:   /* Truncating multi-word to a word or less.  */
        !           947:   if (GET_MODE_BITSIZE (from_mode) > BITS_PER_WORD
        !           948:       && GET_MODE_BITSIZE (to_mode) <= BITS_PER_WORD)
        !           949:     {
        !           950:       if (!((GET_CODE (from) == MEM
        !           951:             && ! MEM_VOLATILE_P (from)
        !           952:             && direct_load[(int) to_mode]
        !           953:             && ! mode_dependent_address_p (XEXP (from, 0)))
        !           954:            || GET_CODE (from) == REG
        !           955:            || GET_CODE (from) == SUBREG))
        !           956:        from = force_reg (from_mode, from);
        !           957:       convert_move (to, gen_lowpart (word_mode, from), 0);
        !           958:       return;
        !           959:     }
        !           960: 
        !           961:   /* Handle pointer conversion */                      /* SPEE 900220 */
        !           962:   if (to_mode == PSImode)
        !           963:     {
        !           964:       if (from_mode != SImode)
        !           965:        from = convert_to_mode (SImode, from, unsignedp);
        !           966: 
        !           967: #ifdef HAVE_truncsipsi
        !           968:       if (HAVE_truncsipsi)
        !           969:        {
        !           970:          emit_unop_insn (CODE_FOR_truncsipsi, to, from, UNKNOWN);
        !           971:          return;
        !           972:        }
        !           973: #endif /* HAVE_truncsipsi */
        !           974:       abort ();
        !           975:     }
        !           976: 
        !           977:   if (from_mode == PSImode)
        !           978:     {
        !           979:       if (to_mode != SImode)
        !           980:        {
        !           981:          from = convert_to_mode (SImode, from, unsignedp);
        !           982:          from_mode = SImode;
        !           983:        }
        !           984:       else
        !           985:        {
        !           986: #ifdef HAVE_extendpsisi
        !           987:          if (HAVE_extendpsisi)
        !           988:            {
        !           989:              emit_unop_insn (CODE_FOR_extendpsisi, to, from, UNKNOWN);
        !           990:              return;
        !           991:            }
        !           992: #endif /* HAVE_extendpsisi */
        !           993:          abort ();
        !           994:        }
        !           995:     }
        !           996: 
        !           997:   /* Now follow all the conversions between integers
        !           998:      no more than a word long.  */
        !           999: 
        !          1000:   /* For truncation, usually we can just refer to FROM in a narrower mode.  */
        !          1001:   if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode)
        !          1002:       && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),
        !          1003:                                GET_MODE_BITSIZE (from_mode)))
        !          1004:     {
        !          1005:       if (!((GET_CODE (from) == MEM
        !          1006:             && ! MEM_VOLATILE_P (from)
        !          1007:             && direct_load[(int) to_mode]
        !          1008:             && ! mode_dependent_address_p (XEXP (from, 0)))
        !          1009:            || GET_CODE (from) == REG
        !          1010:            || GET_CODE (from) == SUBREG))
        !          1011:        from = force_reg (from_mode, from);
        !          1012:       emit_move_insn (to, gen_lowpart (to_mode, from));
        !          1013:       return;
        !          1014:     }
        !          1015: 
        !          1016:   /* Handle extension.  */
        !          1017:   if (GET_MODE_BITSIZE (to_mode) > GET_MODE_BITSIZE (from_mode))
        !          1018:     {
        !          1019:       /* Convert directly if that works.  */
        !          1020:       if ((code = can_extend_p (to_mode, from_mode, unsignedp))
        !          1021:          != CODE_FOR_nothing)
        !          1022:        {
        !          1023:          /* If FROM is a SUBREG, put it into a register.  Do this
        !          1024:             so that we always generate the same set of insns for
        !          1025:             better cse'ing; if an intermediate assignment occurred,
        !          1026:             we won't be doing the operation directly on the SUBREG.  */
        !          1027:          if (optimize > 0 && GET_CODE (from) == SUBREG)
        !          1028:            from = force_reg (from_mode, from);
        !          1029:          emit_unop_insn (code, to, from, equiv_code);
        !          1030:          return;
        !          1031:        }
        !          1032:       else
        !          1033:        {
        !          1034:          enum machine_mode intermediate;
        !          1035: 
        !          1036:          /* Search for a mode to convert via.  */
        !          1037:          for (intermediate = from_mode; intermediate != VOIDmode;
        !          1038:               intermediate = GET_MODE_WIDER_MODE (intermediate))
        !          1039:            if ((can_extend_p (to_mode, intermediate, unsignedp)
        !          1040:                 != CODE_FOR_nothing)
        !          1041:                && (can_extend_p (intermediate, from_mode, unsignedp)
        !          1042:                    != CODE_FOR_nothing))
        !          1043:              {
        !          1044:                convert_move (to, convert_to_mode (intermediate, from,
        !          1045:                                                   unsignedp), unsignedp);
        !          1046:                return;
        !          1047:              }
        !          1048: 
        !          1049:          /* No suitable intermediate mode.  */
        !          1050:          abort ();
        !          1051:        }
        !          1052:     }
        !          1053: 
        !          1054:   /* Support special truncate insns for certain modes.  */ 
        !          1055: 
        !          1056:   if (from_mode == DImode && to_mode == SImode)
        !          1057:     {
        !          1058: #ifdef HAVE_truncdisi2
        !          1059:       if (HAVE_truncdisi2)
        !          1060:        {
        !          1061:          emit_unop_insn (CODE_FOR_truncdisi2, to, from, UNKNOWN);
        !          1062:          return;
        !          1063:        }
        !          1064: #endif
        !          1065:       convert_move (to, force_reg (from_mode, from), unsignedp);
        !          1066:       return;
        !          1067:     }
        !          1068: 
        !          1069:   if (from_mode == DImode && to_mode == HImode)
        !          1070:     {
        !          1071: #ifdef HAVE_truncdihi2
        !          1072:       if (HAVE_truncdihi2)
        !          1073:        {
        !          1074:          emit_unop_insn (CODE_FOR_truncdihi2, to, from, UNKNOWN);
        !          1075:          return;
        !          1076:        }
        !          1077: #endif
        !          1078:       convert_move (to, force_reg (from_mode, from), unsignedp);
        !          1079:       return;
        !          1080:     }
        !          1081: 
        !          1082:   if (from_mode == DImode && to_mode == QImode)
        !          1083:     {
        !          1084: #ifdef HAVE_truncdiqi2
        !          1085:       if (HAVE_truncdiqi2)
        !          1086:        {
        !          1087:          emit_unop_insn (CODE_FOR_truncdiqi2, to, from, UNKNOWN);
        !          1088:          return;
        !          1089:        }
        !          1090: #endif
        !          1091:       convert_move (to, force_reg (from_mode, from), unsignedp);
        !          1092:       return;
        !          1093:     }
        !          1094: 
        !          1095:   if (from_mode == SImode && to_mode == HImode)
        !          1096:     {
        !          1097: #ifdef HAVE_truncsihi2
        !          1098:       if (HAVE_truncsihi2)
        !          1099:        {
        !          1100:          emit_unop_insn (CODE_FOR_truncsihi2, to, from, UNKNOWN);
        !          1101:          return;
        !          1102:        }
        !          1103: #endif
        !          1104:       convert_move (to, force_reg (from_mode, from), unsignedp);
        !          1105:       return;
        !          1106:     }
        !          1107: 
        !          1108:   if (from_mode == SImode && to_mode == QImode)
        !          1109:     {
        !          1110: #ifdef HAVE_truncsiqi2
        !          1111:       if (HAVE_truncsiqi2)
        !          1112:        {
        !          1113:          emit_unop_insn (CODE_FOR_truncsiqi2, to, from, UNKNOWN);
        !          1114:          return;
        !          1115:        }
        !          1116: #endif
        !          1117:       convert_move (to, force_reg (from_mode, from), unsignedp);
        !          1118:       return;
        !          1119:     }
        !          1120: 
        !          1121:   if (from_mode == HImode && to_mode == QImode)
        !          1122:     {
        !          1123: #ifdef HAVE_trunchiqi2
        !          1124:       if (HAVE_trunchiqi2)
        !          1125:        {
        !          1126:          emit_unop_insn (CODE_FOR_trunchiqi2, to, from, UNKNOWN);
        !          1127:          return;
        !          1128:        }
        !          1129: #endif
        !          1130:       convert_move (to, force_reg (from_mode, from), unsignedp);
        !          1131:       return;
        !          1132:     }
        !          1133: 
        !          1134:   /* Handle truncation of volatile memrefs, and so on;
        !          1135:      the things that couldn't be truncated directly,
        !          1136:      and for which there was no special instruction.  */
        !          1137:   if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode))
        !          1138:     {
        !          1139:       rtx temp = force_reg (to_mode, gen_lowpart (to_mode, from));
        !          1140:       emit_move_insn (to, temp);
        !          1141:       return;
        !          1142:     }
        !          1143: 
        !          1144:   /* Mode combination is not recognized.  */
        !          1145:   abort ();
        !          1146: }
        !          1147: 
        !          1148: /* Return an rtx for a value that would result
        !          1149:    from converting X to mode MODE.
        !          1150:    Both X and MODE may be floating, or both integer.
        !          1151:    UNSIGNEDP is nonzero if X is an unsigned value.
        !          1152:    This can be done by referring to a part of X in place
        !          1153:    or by copying to a new temporary with conversion.
        !          1154: 
        !          1155:    This function *must not* call protect_from_queue
        !          1156:    except when putting X into an insn (in which case convert_move does it).  */
        !          1157: 
        !          1158: rtx
        !          1159: convert_to_mode (mode, x, unsignedp)
        !          1160:      enum machine_mode mode;
        !          1161:      rtx x;
        !          1162:      int unsignedp;
        !          1163: {
        !          1164:   return convert_modes (mode, VOIDmode, x, unsignedp);
        !          1165: }
        !          1166: 
        !          1167: /* Return an rtx for a value that would result
        !          1168:    from converting X from mode OLDMODE to mode MODE.
        !          1169:    Both modes may be floating, or both integer.
        !          1170:    UNSIGNEDP is nonzero if X is an unsigned value.
        !          1171: 
        !          1172:    This can be done by referring to a part of X in place
        !          1173:    or by copying to a new temporary with conversion.
        !          1174: 
        !          1175:    You can give VOIDmode for OLDMODE, if you are sure X has a nonvoid mode.
        !          1176: 
        !          1177:    This function *must not* call protect_from_queue
        !          1178:    except when putting X into an insn (in which case convert_move does it).  */
        !          1179: 
        !          1180: rtx
        !          1181: convert_modes (mode, oldmode, x, unsignedp)
        !          1182:      enum machine_mode mode, oldmode;
        !          1183:      rtx x;
        !          1184:      int unsignedp;
        !          1185: {
        !          1186:   register rtx temp;
        !          1187: 
        !          1188:   /* If FROM is a SUBREG that indicates that we have already done at least
        !          1189:      the required extension, strip it.  */
        !          1190: 
        !          1191:   if (GET_CODE (x) == SUBREG && SUBREG_PROMOTED_VAR_P (x)
        !          1192:       && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) >= GET_MODE_SIZE (mode)
        !          1193:       && SUBREG_PROMOTED_UNSIGNED_P (x) == unsignedp)
        !          1194:     x = gen_lowpart (mode, x);
        !          1195: 
        !          1196:   if (GET_MODE (x) != VOIDmode)
        !          1197:     oldmode = GET_MODE (x);
        !          1198:  
        !          1199:   if (mode == oldmode)
        !          1200:     return x;
        !          1201: 
        !          1202:   /* There is one case that we must handle specially: If we are converting
        !          1203:      a CONST_INT into a mode whose size is twice HOST_BITS_PER_WIDE_INT and
        !          1204:      we are to interpret the constant as unsigned, gen_lowpart will do
        !          1205:      the wrong if the constant appears negative.  What we want to do is
        !          1206:      make the high-order word of the constant zero, not all ones.  */
        !          1207: 
        !          1208:   if (unsignedp && GET_MODE_CLASS (mode) == MODE_INT
        !          1209:       && GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT
        !          1210:       && GET_CODE (x) == CONST_INT && INTVAL (x) < 0)
        !          1211:     return immed_double_const (INTVAL (x), (HOST_WIDE_INT) 0, mode);
        !          1212: 
        !          1213:   /* We can do this with a gen_lowpart if both desired and current modes
        !          1214:      are integer, and this is either a constant integer, a register, or a
        !          1215:      non-volatile MEM.  Except for the constant case where MODE is no
        !          1216:      wider than HOST_BITS_PER_WIDE_INT, we must be narrowing the operand.  */
        !          1217: 
        !          1218:   if ((GET_CODE (x) == CONST_INT
        !          1219:        && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
        !          1220:       || (GET_MODE_CLASS (mode) == MODE_INT
        !          1221:          && GET_MODE_CLASS (oldmode) == MODE_INT
        !          1222:          && (GET_CODE (x) == CONST_DOUBLE
        !          1223:              || (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (oldmode)
        !          1224:                  && ((GET_CODE (x) == MEM && ! MEM_VOLATILE_P (x)
        !          1225:                       && direct_load[(int) mode])
        !          1226:                      || GET_CODE (x) == REG)))))
        !          1227:     {
        !          1228:       /* ?? If we don't know OLDMODE, we have to assume here that
        !          1229:         X does not need sign- or zero-extension.   This may not be
        !          1230:         the case, but it's the best we can do.  */
        !          1231:       if (GET_CODE (x) == CONST_INT && oldmode != VOIDmode
        !          1232:          && GET_MODE_SIZE (mode) > GET_MODE_SIZE (oldmode))
        !          1233:        {
        !          1234:          HOST_WIDE_INT val = INTVAL (x);
        !          1235:          int width = GET_MODE_BITSIZE (oldmode);
        !          1236: 
        !          1237:          /* We must sign or zero-extend in this case.  Start by
        !          1238:             zero-extending, then sign extend if we need to.  */
        !          1239:          val &= ((HOST_WIDE_INT) 1 << width) - 1;
        !          1240:          if (! unsignedp
        !          1241:              && (val & ((HOST_WIDE_INT) 1 << (width - 1))))
        !          1242:            val |= (HOST_WIDE_INT) (-1) << width;
        !          1243: 
        !          1244:          return GEN_INT (val);
        !          1245:        }
        !          1246: 
        !          1247:       return gen_lowpart (mode, x);
        !          1248:     }
        !          1249: 
        !          1250:   temp = gen_reg_rtx (mode);
        !          1251:   convert_move (temp, x, unsignedp);
        !          1252:   return temp;
        !          1253: }
        !          1254: 
        !          1255: /* Generate several move instructions to copy LEN bytes
        !          1256:    from block FROM to block TO.  (These are MEM rtx's with BLKmode).
        !          1257:    The caller must pass FROM and TO
        !          1258:     through protect_from_queue before calling.
        !          1259:    ALIGN (in bytes) is maximum alignment we can assume.  */
        !          1260: 
        !          1261: static void
        !          1262: move_by_pieces (to, from, len, align)
        !          1263:      rtx to, from;
        !          1264:      int len, align;
        !          1265: {
        !          1266:   struct move_by_pieces data;
        !          1267:   rtx to_addr = XEXP (to, 0), from_addr = XEXP (from, 0);
        !          1268:   int max_size = MOVE_MAX + 1;
        !          1269: 
        !          1270:   data.offset = 0;
        !          1271:   data.to_addr = to_addr;
        !          1272:   data.from_addr = from_addr;
        !          1273:   data.to = to;
        !          1274:   data.from = from;
        !          1275:   data.autinc_to
        !          1276:     = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
        !          1277:        || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
        !          1278:   data.autinc_from
        !          1279:     = (GET_CODE (from_addr) == PRE_INC || GET_CODE (from_addr) == PRE_DEC
        !          1280:        || GET_CODE (from_addr) == POST_INC
        !          1281:        || GET_CODE (from_addr) == POST_DEC);
        !          1282: 
        !          1283:   data.explicit_inc_from = 0;
        !          1284:   data.explicit_inc_to = 0;
        !          1285:   data.reverse
        !          1286:     = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
        !          1287:   if (data.reverse) data.offset = len;
        !          1288:   data.len = len;
        !          1289: 
        !          1290:   /* If copying requires more than two move insns,
        !          1291:      copy addresses to registers (to make displacements shorter)
        !          1292:      and use post-increment if available.  */
        !          1293:   if (!(data.autinc_from && data.autinc_to)
        !          1294:       && move_by_pieces_ninsns (len, align) > 2)
        !          1295:     {
        !          1296: #ifdef HAVE_PRE_DECREMENT
        !          1297:       if (data.reverse && ! data.autinc_from)
        !          1298:        {
        !          1299:          data.from_addr = copy_addr_to_reg (plus_constant (from_addr, len));
        !          1300:          data.autinc_from = 1;
        !          1301:          data.explicit_inc_from = -1;
        !          1302:        }
        !          1303: #endif
        !          1304: #ifdef HAVE_POST_INCREMENT
        !          1305:       if (! data.autinc_from)
        !          1306:        {
        !          1307:          data.from_addr = copy_addr_to_reg (from_addr);
        !          1308:          data.autinc_from = 1;
        !          1309:          data.explicit_inc_from = 1;
        !          1310:        }
        !          1311: #endif
        !          1312:       if (!data.autinc_from && CONSTANT_P (from_addr))
        !          1313:        data.from_addr = copy_addr_to_reg (from_addr);
        !          1314: #ifdef HAVE_PRE_DECREMENT
        !          1315:       if (data.reverse && ! data.autinc_to)
        !          1316:        {
        !          1317:          data.to_addr = copy_addr_to_reg (plus_constant (to_addr, len));
        !          1318:          data.autinc_to = 1;
        !          1319:          data.explicit_inc_to = -1;
        !          1320:        }
        !          1321: #endif
        !          1322: #ifdef HAVE_POST_INCREMENT
        !          1323:       if (! data.reverse && ! data.autinc_to)
        !          1324:        {
        !          1325:          data.to_addr = copy_addr_to_reg (to_addr);
        !          1326:          data.autinc_to = 1;
        !          1327:          data.explicit_inc_to = 1;
        !          1328:        }
        !          1329: #endif
        !          1330:       if (!data.autinc_to && CONSTANT_P (to_addr))
        !          1331:        data.to_addr = copy_addr_to_reg (to_addr);
        !          1332:     }
        !          1333: 
        !          1334:   if (! (STRICT_ALIGNMENT || SLOW_UNALIGNED_ACCESS)
        !          1335:       || align > MOVE_MAX || align >= BIGGEST_ALIGNMENT / BITS_PER_UNIT)
        !          1336:     align = MOVE_MAX;
        !          1337: 
        !          1338:   /* First move what we can in the largest integer mode, then go to
        !          1339:      successively smaller modes.  */
        !          1340: 
        !          1341:   while (max_size > 1)
        !          1342:     {
        !          1343:       enum machine_mode mode = VOIDmode, tmode;
        !          1344:       enum insn_code icode;
        !          1345: 
        !          1346:       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
        !          1347:           tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
        !          1348:        if (GET_MODE_SIZE (tmode) < max_size)
        !          1349:          mode = tmode;
        !          1350: 
        !          1351:       if (mode == VOIDmode)
        !          1352:        break;
        !          1353: 
        !          1354:       icode = mov_optab->handlers[(int) mode].insn_code;
        !          1355:       if (icode != CODE_FOR_nothing
        !          1356:          && align >= MIN (BIGGEST_ALIGNMENT / BITS_PER_UNIT,
        !          1357:                           GET_MODE_SIZE (mode)))
        !          1358:        move_by_pieces_1 (GEN_FCN (icode), mode, &data);
        !          1359: 
        !          1360:       max_size = GET_MODE_SIZE (mode);
        !          1361:     }
        !          1362: 
        !          1363:   /* The code above should have handled everything.  */
        !          1364:   if (data.len != 0)
        !          1365:     abort ();
        !          1366: }
        !          1367: 
        !          1368: /* Return number of insns required to move L bytes by pieces.
        !          1369:    ALIGN (in bytes) is maximum alignment we can assume.  */
        !          1370: 
        !          1371: static int
        !          1372: move_by_pieces_ninsns (l, align)
        !          1373:      unsigned int l;
        !          1374:      int align;
        !          1375: {
        !          1376:   register int n_insns = 0;
        !          1377:   int max_size = MOVE_MAX + 1;
        !          1378: 
        !          1379:   if (! (STRICT_ALIGNMENT || SLOW_UNALIGNED_ACCESS)
        !          1380:       || align > MOVE_MAX || align >= BIGGEST_ALIGNMENT / BITS_PER_UNIT)
        !          1381:     align = MOVE_MAX;
        !          1382: 
        !          1383:   while (max_size > 1)
        !          1384:     {
        !          1385:       enum machine_mode mode = VOIDmode, tmode;
        !          1386:       enum insn_code icode;
        !          1387: 
        !          1388:       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
        !          1389:           tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
        !          1390:        if (GET_MODE_SIZE (tmode) < max_size)
        !          1391:          mode = tmode;
        !          1392: 
        !          1393:       if (mode == VOIDmode)
        !          1394:        break;
        !          1395: 
        !          1396:       icode = mov_optab->handlers[(int) mode].insn_code;
        !          1397:       if (icode != CODE_FOR_nothing
        !          1398:          && align >= MIN (BIGGEST_ALIGNMENT / BITS_PER_UNIT,
        !          1399:                           GET_MODE_SIZE (mode)))
        !          1400:        n_insns += l / GET_MODE_SIZE (mode), l %= GET_MODE_SIZE (mode);
        !          1401: 
        !          1402:       max_size = GET_MODE_SIZE (mode);
        !          1403:     }
        !          1404: 
        !          1405:   return n_insns;
        !          1406: }
        !          1407: 
        !          1408: /* Subroutine of move_by_pieces.  Move as many bytes as appropriate
        !          1409:    with move instructions for mode MODE.  GENFUN is the gen_... function
        !          1410:    to make a move insn for that mode.  DATA has all the other info.  */
        !          1411: 
        !          1412: static void
        !          1413: move_by_pieces_1 (genfun, mode, data)
        !          1414:      rtx (*genfun) ();
        !          1415:      enum machine_mode mode;
        !          1416:      struct move_by_pieces *data;
        !          1417: {
        !          1418:   register int size = GET_MODE_SIZE (mode);
        !          1419:   register rtx to1, from1;
        !          1420: 
        !          1421:   while (data->len >= size)
        !          1422:     {
        !          1423:       if (data->reverse) data->offset -= size;
        !          1424: 
        !          1425:       to1 = (data->autinc_to
        !          1426:             ? gen_rtx (MEM, mode, data->to_addr)
        !          1427:             : change_address (data->to, mode,
        !          1428:                               plus_constant (data->to_addr, data->offset)));
        !          1429:       from1 =
        !          1430:        (data->autinc_from
        !          1431:         ? gen_rtx (MEM, mode, data->from_addr)
        !          1432:         : change_address (data->from, mode,
        !          1433:                           plus_constant (data->from_addr, data->offset)));
        !          1434: 
        !          1435: #ifdef HAVE_PRE_DECREMENT
        !          1436:       if (data->explicit_inc_to < 0)
        !          1437:        emit_insn (gen_add2_insn (data->to_addr, GEN_INT (-size)));
        !          1438:       if (data->explicit_inc_from < 0)
        !          1439:        emit_insn (gen_add2_insn (data->from_addr, GEN_INT (-size)));
        !          1440: #endif
        !          1441: 
        !          1442:       emit_insn ((*genfun) (to1, from1));
        !          1443: #ifdef HAVE_POST_INCREMENT
        !          1444:       if (data->explicit_inc_to > 0)
        !          1445:        emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
        !          1446:       if (data->explicit_inc_from > 0)
        !          1447:        emit_insn (gen_add2_insn (data->from_addr, GEN_INT (size)));
        !          1448: #endif
        !          1449: 
        !          1450:       if (! data->reverse) data->offset += size;
        !          1451: 
        !          1452:       data->len -= size;
        !          1453:     }
        !          1454: }
        !          1455: 
        !          1456: /* Emit code to move a block Y to a block X.
        !          1457:    This may be done with string-move instructions,
        !          1458:    with multiple scalar move instructions, or with a library call.
        !          1459: 
        !          1460:    Both X and Y must be MEM rtx's (perhaps inside VOLATILE)
        !          1461:    with mode BLKmode.
        !          1462:    SIZE is an rtx that says how long they are.
        !          1463:    ALIGN is the maximum alignment we can assume they have,
        !          1464:    measured in bytes.  */
        !          1465: 
        !          1466: void
        !          1467: emit_block_move (x, y, size, align)
        !          1468:      rtx x, y;
        !          1469:      rtx size;
        !          1470:      int align;
        !          1471: {
        !          1472:   if (GET_MODE (x) != BLKmode)
        !          1473:     abort ();
        !          1474: 
        !          1475:   if (GET_MODE (y) != BLKmode)
        !          1476:     abort ();
        !          1477: 
        !          1478:   x = protect_from_queue (x, 1);
        !          1479:   y = protect_from_queue (y, 0);
        !          1480:   size = protect_from_queue (size, 0);
        !          1481: 
        !          1482:   if (GET_CODE (x) != MEM)
        !          1483:     abort ();
        !          1484:   if (GET_CODE (y) != MEM)
        !          1485:     abort ();
        !          1486:   if (size == 0)
        !          1487:     abort ();
        !          1488: 
        !          1489:   if (GET_CODE (size) == CONST_INT
        !          1490:       && (move_by_pieces_ninsns (INTVAL (size), align) < MOVE_RATIO))
        !          1491:     move_by_pieces (x, y, INTVAL (size), align);
        !          1492:   else
        !          1493:     {
        !          1494:       /* Try the most limited insn first, because there's no point
        !          1495:         including more than one in the machine description unless
        !          1496:         the more limited one has some advantage.  */
        !          1497: 
        !          1498:       rtx opalign = GEN_INT (align);
        !          1499:       enum machine_mode mode;
        !          1500: 
        !          1501:       for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
        !          1502:           mode = GET_MODE_WIDER_MODE (mode))
        !          1503:        {
        !          1504:          enum insn_code code = movstr_optab[(int) mode];
        !          1505: 
        !          1506:          if (code != CODE_FOR_nothing
        !          1507:              /* We don't need MODE to be narrower than BITS_PER_HOST_WIDE_INT
        !          1508:                 here because if SIZE is less than the mode mask, as it is
        !          1509:                 returned by the macro, it will definitely be less than the
        !          1510:                 actual mode mask.  */
        !          1511:              && (unsigned HOST_WIDE_INT) INTVAL (size) <= GET_MODE_MASK (mode)
        !          1512:              && (insn_operand_predicate[(int) code][0] == 0
        !          1513:                  || (*insn_operand_predicate[(int) code][0]) (x, BLKmode))
        !          1514:              && (insn_operand_predicate[(int) code][1] == 0
        !          1515:                  || (*insn_operand_predicate[(int) code][1]) (y, BLKmode))
        !          1516:              && (insn_operand_predicate[(int) code][3] == 0
        !          1517:                  || (*insn_operand_predicate[(int) code][3]) (opalign,
        !          1518:                                                               VOIDmode)))
        !          1519:            {
        !          1520:              rtx op2;
        !          1521:              rtx last = get_last_insn ();
        !          1522:              rtx pat;
        !          1523: 
        !          1524:              op2 = convert_to_mode (mode, size, 1);
        !          1525:              if (insn_operand_predicate[(int) code][2] != 0
        !          1526:                  && ! (*insn_operand_predicate[(int) code][2]) (op2, mode))
        !          1527:                op2 = copy_to_mode_reg (mode, op2);
        !          1528: 
        !          1529:              pat = GEN_FCN ((int) code) (x, y, op2, opalign);
        !          1530:              if (pat)
        !          1531:                {
        !          1532:                  emit_insn (pat);
        !          1533:                  return;
        !          1534:                }
        !          1535:              else
        !          1536:                delete_insns_since (last);
        !          1537:            }
        !          1538:        }
        !          1539: 
        !          1540: #ifdef TARGET_MEM_FUNCTIONS
        !          1541:       emit_library_call (memcpy_libfunc, 0,
        !          1542:                         VOIDmode, 3, XEXP (x, 0), Pmode,
        !          1543:                         XEXP (y, 0), Pmode,
        !          1544:                         convert_to_mode (TYPE_MODE (sizetype), size,
        !          1545:                                          TREE_UNSIGNED (sizetype)),
        !          1546:                         TYPE_MODE (sizetype));
        !          1547: #else
        !          1548:       emit_library_call (bcopy_libfunc, 0,
        !          1549:                         VOIDmode, 3, XEXP (y, 0), Pmode,
        !          1550:                         XEXP (x, 0), Pmode,
        !          1551:                         convert_to_mode (TYPE_MODE (sizetype), size,
        !          1552:                                          TREE_UNSIGNED (sizetype)),
        !          1553:                         TYPE_MODE (sizetype));
        !          1554: #endif
        !          1555:     }
        !          1556: }
        !          1557: 
        !          1558: /* Copy all or part of a value X into registers starting at REGNO.
        !          1559:    The number of registers to be filled is NREGS.  */
        !          1560: 
        !          1561: void
        !          1562: move_block_to_reg (regno, x, nregs, mode)
        !          1563:      int regno;
        !          1564:      rtx x;
        !          1565:      int nregs;
        !          1566:      enum machine_mode mode;
        !          1567: {
        !          1568:   int i;
        !          1569:   rtx pat, last;
        !          1570: 
        !          1571:   if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
        !          1572:     x = validize_mem (force_const_mem (mode, x));
        !          1573: 
        !          1574:   /* See if the machine can do this with a load multiple insn.  */
        !          1575: #ifdef HAVE_load_multiple
        !          1576:   if (HAVE_load_multiple)
        !          1577:     {
        !          1578:       last = get_last_insn ();
        !          1579:       pat = gen_load_multiple (gen_rtx (REG, word_mode, regno), x,
        !          1580:                               GEN_INT (nregs));
        !          1581:       if (pat)
        !          1582:        {
        !          1583:          emit_insn (pat);
        !          1584:          return;
        !          1585:        }
        !          1586:       else
        !          1587:        delete_insns_since (last);
        !          1588:     }
        !          1589: #endif
        !          1590: 
        !          1591:   for (i = 0; i < nregs; i++)
        !          1592:     emit_move_insn (gen_rtx (REG, word_mode, regno + i),
        !          1593:                    operand_subword_force (x, i, mode));
        !          1594: }
        !          1595: 
        !          1596: /* Copy all or part of a BLKmode value X out of registers starting at REGNO.
        !          1597:    The number of registers to be filled is NREGS.  SIZE indicates the number
        !          1598:    of bytes in the object X.  */
        !          1599: 
        !          1600: 
        !          1601: void
        !          1602: move_block_from_reg (regno, x, nregs, size)
        !          1603:      int regno;
        !          1604:      rtx x;
        !          1605:      int nregs;
        !          1606:      int size;
        !          1607: {
        !          1608:   int i;
        !          1609:   rtx pat, last;
        !          1610: 
        !          1611:   /* Blocks smaller than a word on a BYTES_BIG_ENDIAN machine must be aligned
        !          1612:      to the left before storing to memory.  */
        !          1613:   if (size < UNITS_PER_WORD && BYTES_BIG_ENDIAN)
        !          1614:     {
        !          1615:       rtx tem = operand_subword (x, 0, 1, BLKmode);
        !          1616:       rtx shift;
        !          1617: 
        !          1618:       if (tem == 0)
        !          1619:        abort ();
        !          1620: 
        !          1621:       shift = expand_shift (LSHIFT_EXPR, word_mode,
        !          1622:                            gen_rtx (REG, word_mode, regno),
        !          1623:                            build_int_2 ((UNITS_PER_WORD - size)
        !          1624:                                         * BITS_PER_UNIT, 0), NULL_RTX, 0);
        !          1625:       emit_move_insn (tem, shift);
        !          1626:       return;
        !          1627:     }
        !          1628: 
        !          1629:   /* See if the machine can do this with a store multiple insn.  */
        !          1630: #ifdef HAVE_store_multiple
        !          1631:   if (HAVE_store_multiple)
        !          1632:     {
        !          1633:       last = get_last_insn ();
        !          1634:       pat = gen_store_multiple (x, gen_rtx (REG, word_mode, regno),
        !          1635:                                GEN_INT (nregs));
        !          1636:       if (pat)
        !          1637:        {
        !          1638:          emit_insn (pat);
        !          1639:          return;
        !          1640:        }
        !          1641:       else
        !          1642:        delete_insns_since (last);
        !          1643:     }
        !          1644: #endif
        !          1645: 
        !          1646:   for (i = 0; i < nregs; i++)
        !          1647:     {
        !          1648:       rtx tem = operand_subword (x, i, 1, BLKmode);
        !          1649: 
        !          1650:       if (tem == 0)
        !          1651:        abort ();
        !          1652: 
        !          1653:       emit_move_insn (tem, gen_rtx (REG, word_mode, regno + i));
        !          1654:     }
        !          1655: }
        !          1656: 
        !          1657: /* Mark NREGS consecutive regs, starting at REGNO, as being live now.  */
        !          1658: 
        !          1659: void
        !          1660: use_regs (regno, nregs)
        !          1661:      int regno;
        !          1662:      int nregs;
        !          1663: {
        !          1664:   int i;
        !          1665: 
        !          1666:   for (i = 0; i < nregs; i++)
        !          1667:     emit_insn (gen_rtx (USE, VOIDmode, gen_rtx (REG, word_mode, regno + i)));
        !          1668: }
        !          1669: 
        !          1670: /* Mark the instructions since PREV as a libcall block.
        !          1671:    Add REG_LIBCALL to PREV and add a REG_RETVAL to the most recent insn.  */
        !          1672: 
        !          1673: static void
        !          1674: group_insns (prev)
        !          1675:      rtx prev;
        !          1676: {
        !          1677:   rtx insn_first;
        !          1678:   rtx insn_last;
        !          1679: 
        !          1680:   /* Find the instructions to mark */
        !          1681:   if (prev)
        !          1682:     insn_first = NEXT_INSN (prev);
        !          1683:   else
        !          1684:     insn_first = get_insns ();
        !          1685: 
        !          1686:   insn_last = get_last_insn ();
        !          1687: 
        !          1688:   REG_NOTES (insn_last) = gen_rtx (INSN_LIST, REG_RETVAL, insn_first,
        !          1689:                                   REG_NOTES (insn_last));
        !          1690: 
        !          1691:   REG_NOTES (insn_first) = gen_rtx (INSN_LIST, REG_LIBCALL, insn_last,
        !          1692:                                    REG_NOTES (insn_first));
        !          1693: }
        !          1694: 
        !          1695: /* Write zeros through the storage of OBJECT.
        !          1696:    If OBJECT has BLKmode, SIZE is its length in bytes.  */
        !          1697: 
        !          1698: void
        !          1699: clear_storage (object, size)
        !          1700:      rtx object;
        !          1701:      int size;
        !          1702: {
        !          1703:   if (GET_MODE (object) == BLKmode)
        !          1704:     {
        !          1705: #ifdef TARGET_MEM_FUNCTIONS
        !          1706:       emit_library_call (memset_libfunc, 0,
        !          1707:                         VOIDmode, 3,
        !          1708:                         XEXP (object, 0), Pmode, const0_rtx, Pmode,
        !          1709:                         GEN_INT (size), Pmode);
        !          1710: #else
        !          1711:       emit_library_call (bzero_libfunc, 0,
        !          1712:                         VOIDmode, 2,
        !          1713:                         XEXP (object, 0), Pmode,
        !          1714:                         GEN_INT (size), Pmode);
        !          1715: #endif
        !          1716:     }
        !          1717:   else
        !          1718:     emit_move_insn (object, const0_rtx);
        !          1719: }
        !          1720: 
        !          1721: /* Generate code to copy Y into X.
        !          1722:    Both Y and X must have the same mode, except that
        !          1723:    Y can be a constant with VOIDmode.
        !          1724:    This mode cannot be BLKmode; use emit_block_move for that.
        !          1725: 
        !          1726:    Return the last instruction emitted.  */
        !          1727: 
        !          1728: rtx
        !          1729: emit_move_insn (x, y)
        !          1730:      rtx x, y;
        !          1731: {
        !          1732:   enum machine_mode mode = GET_MODE (x);
        !          1733:   enum machine_mode submode;
        !          1734:   enum mode_class class = GET_MODE_CLASS (mode);
        !          1735:   int i;
        !          1736: 
        !          1737:   x = protect_from_queue (x, 1);
        !          1738:   y = protect_from_queue (y, 0);
        !          1739: 
        !          1740:   if (mode == BLKmode || (GET_MODE (y) != mode && GET_MODE (y) != VOIDmode))
        !          1741:     abort ();
        !          1742: 
        !          1743:   if (CONSTANT_P (y) && ! LEGITIMATE_CONSTANT_P (y))
        !          1744:     y = force_const_mem (mode, y);
        !          1745: 
        !          1746:   /* If X or Y are memory references, verify that their addresses are valid
        !          1747:      for the machine.  */
        !          1748:   if (GET_CODE (x) == MEM
        !          1749:       && ((! memory_address_p (GET_MODE (x), XEXP (x, 0))
        !          1750:           && ! push_operand (x, GET_MODE (x)))
        !          1751:          || (flag_force_addr
        !          1752:              && CONSTANT_ADDRESS_P (XEXP (x, 0)))))
        !          1753:     x = change_address (x, VOIDmode, XEXP (x, 0));
        !          1754: 
        !          1755:   if (GET_CODE (y) == MEM
        !          1756:       && (! memory_address_p (GET_MODE (y), XEXP (y, 0))
        !          1757:          || (flag_force_addr
        !          1758:              && CONSTANT_ADDRESS_P (XEXP (y, 0)))))
        !          1759:     y = change_address (y, VOIDmode, XEXP (y, 0));
        !          1760: 
        !          1761:   if (mode == BLKmode)
        !          1762:     abort ();
        !          1763: 
        !          1764:   return emit_move_insn_1 (x, y);
        !          1765: }
        !          1766: 
        !          1767: /* Low level part of emit_move_insn.
        !          1768:    Called just like emit_move_insn, but assumes X and Y
        !          1769:    are basically valid.  */
        !          1770: 
        !          1771: rtx
        !          1772: emit_move_insn_1 (x, y)
        !          1773:      rtx x, y;
        !          1774: {
        !          1775:   enum machine_mode mode = GET_MODE (x);
        !          1776:   enum machine_mode submode;
        !          1777:   enum mode_class class = GET_MODE_CLASS (mode);
        !          1778:   int i;
        !          1779: 
        !          1780:   if (class == MODE_COMPLEX_FLOAT || class == MODE_COMPLEX_INT)
        !          1781:     submode = mode_for_size (GET_MODE_UNIT_SIZE (mode) * BITS_PER_UNIT,
        !          1782:                             (class == MODE_COMPLEX_INT
        !          1783:                              ? MODE_INT : MODE_FLOAT),
        !          1784:                             0);
        !          1785: 
        !          1786:   if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
        !          1787:     return
        !          1788:       emit_insn (GEN_FCN (mov_optab->handlers[(int) mode].insn_code) (x, y));
        !          1789: 
        !          1790:   /* Expand complex moves by moving real part and imag part, if possible.  */
        !          1791:   else if ((class == MODE_COMPLEX_FLOAT || class == MODE_COMPLEX_INT)
        !          1792:           && submode != BLKmode
        !          1793:           && (mov_optab->handlers[(int) submode].insn_code
        !          1794:               != CODE_FOR_nothing))
        !          1795:     {
        !          1796:       /* Don't split destination if it is a stack push.  */
        !          1797:       int stack = push_operand (x, GET_MODE (x));
        !          1798:       rtx prev = get_last_insn ();
        !          1799: 
        !          1800:       /* Tell flow that the whole of the destination is being set.  */
        !          1801:       if (GET_CODE (x) == REG)
        !          1802:        emit_insn (gen_rtx (CLOBBER, VOIDmode, x));
        !          1803: 
        !          1804:       /* If this is a stack, push the highpart first, so it
        !          1805:         will be in the argument order.
        !          1806: 
        !          1807:         In that case, change_address is used only to convert
        !          1808:         the mode, not to change the address.  */
        !          1809:       if (stack)
        !          1810:        {
        !          1811:          /* Note that the real part always precedes the imag part in memory
        !          1812:             regardless of machine's endianness.  */
        !          1813: #ifdef STACK_GROWS_DOWNWARD
        !          1814:          emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
        !          1815:                     (gen_rtx (MEM, submode, (XEXP (x, 0))),
        !          1816:                      gen_imagpart (submode, y)));
        !          1817:          emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
        !          1818:                     (gen_rtx (MEM, submode, (XEXP (x, 0))),
        !          1819:                      gen_realpart (submode, y)));
        !          1820: #else
        !          1821:          emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
        !          1822:                     (gen_rtx (MEM, submode, (XEXP (x, 0))),
        !          1823:                      gen_realpart (submode, y)));
        !          1824:          emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
        !          1825:                     (gen_rtx (MEM, submode, (XEXP (x, 0))),
        !          1826:                      gen_imagpart (submode, y)));
        !          1827: #endif
        !          1828:        }
        !          1829:       else
        !          1830:        {
        !          1831:          emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
        !          1832:                     (gen_highpart (submode, x), gen_highpart (submode, y)));
        !          1833:          emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
        !          1834:                     (gen_lowpart (submode, x), gen_lowpart (submode, y)));
        !          1835:        }
        !          1836: 
        !          1837:       if (GET_CODE (x) != CONCAT)
        !          1838:        /* If X is a CONCAT, we got insns like RD = RS, ID = IS,
        !          1839:           each with a separate pseudo as destination.
        !          1840:           It's not correct for flow to treat them as a unit.  */
        !          1841:        group_insns (prev);
        !          1842: 
        !          1843:       return get_last_insn ();
        !          1844:     }
        !          1845: 
        !          1846:   /* This will handle any multi-word mode that lacks a move_insn pattern.
        !          1847:      However, you will get better code if you define such patterns,
        !          1848:      even if they must turn into multiple assembler instructions.  */
        !          1849:   else if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
        !          1850:     {
        !          1851:       rtx last_insn = 0;
        !          1852:       rtx prev_insn = get_last_insn ();
        !          1853: 
        !          1854:       for (i = 0;
        !          1855:           i < (GET_MODE_SIZE (mode)  + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
        !          1856:           i++)
        !          1857:        {
        !          1858:          rtx xpart = operand_subword (x, i, 1, mode);
        !          1859:          rtx ypart = operand_subword (y, i, 1, mode);
        !          1860: 
        !          1861:          /* If we can't get a part of Y, put Y into memory if it is a
        !          1862:             constant.  Otherwise, force it into a register.  If we still
        !          1863:             can't get a part of Y, abort.  */
        !          1864:          if (ypart == 0 && CONSTANT_P (y))
        !          1865:            {
        !          1866:              y = force_const_mem (mode, y);
        !          1867:              ypart = operand_subword (y, i, 1, mode);
        !          1868:            }
        !          1869:          else if (ypart == 0)
        !          1870:            ypart = operand_subword_force (y, i, mode);
        !          1871: 
        !          1872:          if (xpart == 0 || ypart == 0)
        !          1873:            abort ();
        !          1874: 
        !          1875:          last_insn = emit_move_insn (xpart, ypart);
        !          1876:        }
        !          1877:       /* Mark these insns as a libcall block.  */
        !          1878:       group_insns (prev_insn);
        !          1879: 
        !          1880:       return last_insn;
        !          1881:     }
        !          1882:   else
        !          1883:     abort ();
        !          1884: }
        !          1885: 
        !          1886: /* Pushing data onto the stack.  */
        !          1887: 
        !          1888: /* Push a block of length SIZE (perhaps variable)
        !          1889:    and return an rtx to address the beginning of the block.
        !          1890:    Note that it is not possible for the value returned to be a QUEUED.
        !          1891:    The value may be virtual_outgoing_args_rtx.
        !          1892: 
        !          1893:    EXTRA is the number of bytes of padding to push in addition to SIZE.
        !          1894:    BELOW nonzero means this padding comes at low addresses;
        !          1895:    otherwise, the padding comes at high addresses.  */
        !          1896: 
        !          1897: rtx
        !          1898: push_block (size, extra, below)
        !          1899:      rtx size;
        !          1900:      int extra, below;
        !          1901: {
        !          1902:   register rtx temp;
        !          1903:   if (CONSTANT_P (size))
        !          1904:     anti_adjust_stack (plus_constant (size, extra));
        !          1905:   else if (GET_CODE (size) == REG && extra == 0)
        !          1906:     anti_adjust_stack (size);
        !          1907:   else
        !          1908:     {
        !          1909:       rtx temp = copy_to_mode_reg (Pmode, size);
        !          1910:       if (extra != 0)
        !          1911:        temp = expand_binop (Pmode, add_optab, temp, GEN_INT (extra),
        !          1912:                             temp, 0, OPTAB_LIB_WIDEN);
        !          1913:       anti_adjust_stack (temp);
        !          1914:     }
        !          1915: 
        !          1916: #ifdef STACK_GROWS_DOWNWARD
        !          1917:   temp = virtual_outgoing_args_rtx;
        !          1918:   if (extra != 0 && below)
        !          1919:     temp = plus_constant (temp, extra);
        !          1920: #else
        !          1921:   if (GET_CODE (size) == CONST_INT)
        !          1922:     temp = plus_constant (virtual_outgoing_args_rtx,
        !          1923:                          - INTVAL (size) - (below ? 0 : extra));
        !          1924:   else if (extra != 0 && !below)
        !          1925:     temp = gen_rtx (PLUS, Pmode, virtual_outgoing_args_rtx,
        !          1926:                    negate_rtx (Pmode, plus_constant (size, extra)));
        !          1927:   else
        !          1928:     temp = gen_rtx (PLUS, Pmode, virtual_outgoing_args_rtx,
        !          1929:                    negate_rtx (Pmode, size));
        !          1930: #endif
        !          1931: 
        !          1932:   return memory_address (GET_CLASS_NARROWEST_MODE (MODE_INT), temp);
        !          1933: }
        !          1934: 
        !          1935: rtx
        !          1936: gen_push_operand ()
        !          1937: {
        !          1938:   return gen_rtx (STACK_PUSH_CODE, Pmode, stack_pointer_rtx);
        !          1939: }
        !          1940: 
        !          1941: /* Generate code to push X onto the stack, assuming it has mode MODE and
        !          1942:    type TYPE.
        !          1943:    MODE is redundant except when X is a CONST_INT (since they don't
        !          1944:    carry mode info).
        !          1945:    SIZE is an rtx for the size of data to be copied (in bytes),
        !          1946:    needed only if X is BLKmode.
        !          1947: 
        !          1948:    ALIGN (in bytes) is maximum alignment we can assume.
        !          1949: 
        !          1950:    If PARTIAL and REG are both nonzero, then copy that many of the first
        !          1951:    words of X into registers starting with REG, and push the rest of X.
        !          1952:    The amount of space pushed is decreased by PARTIAL words,
        !          1953:    rounded *down* to a multiple of PARM_BOUNDARY.
        !          1954:    REG must be a hard register in this case.
        !          1955:    If REG is zero but PARTIAL is not, take any all others actions for an
        !          1956:    argument partially in registers, but do not actually load any
        !          1957:    registers.
        !          1958: 
        !          1959:    EXTRA is the amount in bytes of extra space to leave next to this arg.
        !          1960:    This is ignored if an argument block has already been allocated.
        !          1961: 
        !          1962:    On a machine that lacks real push insns, ARGS_ADDR is the address of
        !          1963:    the bottom of the argument block for this call.  We use indexing off there
        !          1964:    to store the arg.  On machines with push insns, ARGS_ADDR is 0 when a
        !          1965:    argument block has not been preallocated.
        !          1966: 
        !          1967:    ARGS_SO_FAR is the size of args previously pushed for this call.  */
        !          1968: 
        !          1969: void
        !          1970: emit_push_insn (x, mode, type, size, align, partial, reg, extra,
        !          1971:                args_addr, args_so_far)
        !          1972:      register rtx x;
        !          1973:      enum machine_mode mode;
        !          1974:      tree type;
        !          1975:      rtx size;
        !          1976:      int align;
        !          1977:      int partial;
        !          1978:      rtx reg;
        !          1979:      int extra;
        !          1980:      rtx args_addr;
        !          1981:      rtx args_so_far;
        !          1982: {
        !          1983:   rtx xinner;
        !          1984:   enum direction stack_direction
        !          1985: #ifdef STACK_GROWS_DOWNWARD
        !          1986:     = downward;
        !          1987: #else
        !          1988:     = upward;
        !          1989: #endif
        !          1990: 
        !          1991:   /* Decide where to pad the argument: `downward' for below,
        !          1992:      `upward' for above, or `none' for don't pad it.
        !          1993:      Default is below for small data on big-endian machines; else above.  */
        !          1994:   enum direction where_pad = FUNCTION_ARG_PADDING (mode, type);
        !          1995: 
        !          1996:   /* Invert direction if stack is post-update.  */
        !          1997:   if (STACK_PUSH_CODE == POST_INC || STACK_PUSH_CODE == POST_DEC)
        !          1998:     if (where_pad != none)
        !          1999:       where_pad = (where_pad == downward ? upward : downward);
        !          2000: 
        !          2001:   xinner = x = protect_from_queue (x, 0);
        !          2002: 
        !          2003:   if (mode == BLKmode)
        !          2004:     {
        !          2005:       /* Copy a block into the stack, entirely or partially.  */
        !          2006: 
        !          2007:       register rtx temp;
        !          2008:       int used = partial * UNITS_PER_WORD;
        !          2009:       int offset = used % (PARM_BOUNDARY / BITS_PER_UNIT);
        !          2010:       int skip;
        !          2011:       
        !          2012:       if (size == 0)
        !          2013:        abort ();
        !          2014: 
        !          2015:       used -= offset;
        !          2016: 
        !          2017:       /* USED is now the # of bytes we need not copy to the stack
        !          2018:         because registers will take care of them.  */
        !          2019: 
        !          2020:       if (partial != 0)
        !          2021:        xinner = change_address (xinner, BLKmode,
        !          2022:                                 plus_constant (XEXP (xinner, 0), used));
        !          2023: 
        !          2024:       /* If the partial register-part of the arg counts in its stack size,
        !          2025:         skip the part of stack space corresponding to the registers.
        !          2026:         Otherwise, start copying to the beginning of the stack space,
        !          2027:         by setting SKIP to 0.  */
        !          2028: #ifndef REG_PARM_STACK_SPACE
        !          2029:       skip = 0;
        !          2030: #else
        !          2031:       skip = used;
        !          2032: #endif
        !          2033: 
        !          2034: #ifdef PUSH_ROUNDING
        !          2035:       /* Do it with several push insns if that doesn't take lots of insns
        !          2036:         and if there is no difficulty with push insns that skip bytes
        !          2037:         on the stack for alignment purposes.  */
        !          2038:       if (args_addr == 0
        !          2039:          && GET_CODE (size) == CONST_INT
        !          2040:          && skip == 0
        !          2041:          && (move_by_pieces_ninsns ((unsigned) INTVAL (size) - used, align)
        !          2042:              < MOVE_RATIO)
        !          2043:          /* Here we avoid the case of a structure whose weak alignment
        !          2044:             forces many pushes of a small amount of data,
        !          2045:             and such small pushes do rounding that causes trouble.  */
        !          2046:          && ((! STRICT_ALIGNMENT && ! SLOW_UNALIGNED_ACCESS)
        !          2047:              || align >= BIGGEST_ALIGNMENT / BITS_PER_UNIT
        !          2048:              || PUSH_ROUNDING (align) == align)
        !          2049:          && PUSH_ROUNDING (INTVAL (size)) == INTVAL (size))
        !          2050:        {
        !          2051:          /* Push padding now if padding above and stack grows down,
        !          2052:             or if padding below and stack grows up.
        !          2053:             But if space already allocated, this has already been done.  */
        !          2054:          if (extra && args_addr == 0
        !          2055:              && where_pad != none && where_pad != stack_direction)
        !          2056:            anti_adjust_stack (GEN_INT (extra));
        !          2057: 
        !          2058:          move_by_pieces (gen_rtx (MEM, BLKmode, gen_push_operand ()), xinner,
        !          2059:                          INTVAL (size) - used, align);
        !          2060:        }
        !          2061:       else
        !          2062: #endif /* PUSH_ROUNDING */
        !          2063:        {
        !          2064:          /* Otherwise make space on the stack and copy the data
        !          2065:             to the address of that space.  */
        !          2066: 
        !          2067:          /* Deduct words put into registers from the size we must copy.  */
        !          2068:          if (partial != 0)
        !          2069:            {
        !          2070:              if (GET_CODE (size) == CONST_INT)
        !          2071:                size = GEN_INT (INTVAL (size) - used);
        !          2072:              else
        !          2073:                size = expand_binop (GET_MODE (size), sub_optab, size,
        !          2074:                                     GEN_INT (used), NULL_RTX, 0,
        !          2075:                                     OPTAB_LIB_WIDEN);
        !          2076:            }
        !          2077: 
        !          2078:          /* Get the address of the stack space.
        !          2079:             In this case, we do not deal with EXTRA separately.
        !          2080:             A single stack adjust will do.  */
        !          2081:          if (! args_addr)
        !          2082:            {
        !          2083:              temp = push_block (size, extra, where_pad == downward);
        !          2084:              extra = 0;
        !          2085:            }
        !          2086:          else if (GET_CODE (args_so_far) == CONST_INT)
        !          2087:            temp = memory_address (BLKmode,
        !          2088:                                   plus_constant (args_addr,
        !          2089:                                                  skip + INTVAL (args_so_far)));
        !          2090:          else
        !          2091:            temp = memory_address (BLKmode,
        !          2092:                                   plus_constant (gen_rtx (PLUS, Pmode,
        !          2093:                                                           args_addr, args_so_far),
        !          2094:                                                  skip));
        !          2095: 
        !          2096:          /* TEMP is the address of the block.  Copy the data there.  */
        !          2097:          if (GET_CODE (size) == CONST_INT
        !          2098:              && (move_by_pieces_ninsns ((unsigned) INTVAL (size), align)
        !          2099:                  < MOVE_RATIO))
        !          2100:            {
        !          2101:              move_by_pieces (gen_rtx (MEM, BLKmode, temp), xinner,
        !          2102:                              INTVAL (size), align);
        !          2103:              goto ret;
        !          2104:            }
        !          2105:          /* Try the most limited insn first, because there's no point
        !          2106:             including more than one in the machine description unless
        !          2107:             the more limited one has some advantage.  */
        !          2108: #ifdef HAVE_movstrqi
        !          2109:          if (HAVE_movstrqi
        !          2110:              && GET_CODE (size) == CONST_INT
        !          2111:              && ((unsigned) INTVAL (size)
        !          2112:                  < (1 << (GET_MODE_BITSIZE (QImode) - 1))))
        !          2113:            {
        !          2114:              rtx pat = gen_movstrqi (gen_rtx (MEM, BLKmode, temp),
        !          2115:                                      xinner, size, GEN_INT (align));
        !          2116:              if (pat != 0)
        !          2117:                {
        !          2118:                  emit_insn (pat);
        !          2119:                  goto ret;
        !          2120:                }
        !          2121:            }
        !          2122: #endif
        !          2123: #ifdef HAVE_movstrhi
        !          2124:          if (HAVE_movstrhi
        !          2125:              && GET_CODE (size) == CONST_INT
        !          2126:              && ((unsigned) INTVAL (size)
        !          2127:                  < (1 << (GET_MODE_BITSIZE (HImode) - 1))))
        !          2128:            {
        !          2129:              rtx pat = gen_movstrhi (gen_rtx (MEM, BLKmode, temp),
        !          2130:                                      xinner, size, GEN_INT (align));
        !          2131:              if (pat != 0)
        !          2132:                {
        !          2133:                  emit_insn (pat);
        !          2134:                  goto ret;
        !          2135:                }
        !          2136:            }
        !          2137: #endif
        !          2138: #ifdef HAVE_movstrsi
        !          2139:          if (HAVE_movstrsi)
        !          2140:            {
        !          2141:              rtx pat = gen_movstrsi (gen_rtx (MEM, BLKmode, temp),
        !          2142:                                      xinner, size, GEN_INT (align));
        !          2143:              if (pat != 0)
        !          2144:                {
        !          2145:                  emit_insn (pat);
        !          2146:                  goto ret;
        !          2147:                }
        !          2148:            }
        !          2149: #endif
        !          2150: #ifdef HAVE_movstrdi
        !          2151:          if (HAVE_movstrdi)
        !          2152:            {
        !          2153:              rtx pat = gen_movstrdi (gen_rtx (MEM, BLKmode, temp),
        !          2154:                                      xinner, size, GEN_INT (align));
        !          2155:              if (pat != 0)
        !          2156:                {
        !          2157:                  emit_insn (pat);
        !          2158:                  goto ret;
        !          2159:                }
        !          2160:            }
        !          2161: #endif
        !          2162: 
        !          2163: #ifndef ACCUMULATE_OUTGOING_ARGS
        !          2164:          /* If the source is referenced relative to the stack pointer,
        !          2165:             copy it to another register to stabilize it.  We do not need
        !          2166:             to do this if we know that we won't be changing sp.  */
        !          2167: 
        !          2168:          if (reg_mentioned_p (virtual_stack_dynamic_rtx, temp)
        !          2169:              || reg_mentioned_p (virtual_outgoing_args_rtx, temp))
        !          2170:            temp = copy_to_reg (temp);
        !          2171: #endif
        !          2172: 
        !          2173:          /* Make inhibit_defer_pop nonzero around the library call
        !          2174:             to force it to pop the bcopy-arguments right away.  */
        !          2175:          NO_DEFER_POP;
        !          2176: #ifdef TARGET_MEM_FUNCTIONS
        !          2177:          emit_library_call (memcpy_libfunc, 0,
        !          2178:                             VOIDmode, 3, temp, Pmode, XEXP (xinner, 0), Pmode,
        !          2179:                             convert_to_mode (TYPE_MODE (sizetype),
        !          2180:                                              size, TREE_UNSIGNED (sizetype)),
        !          2181:                             TYPE_MODE (sizetype));
        !          2182: #else
        !          2183:          emit_library_call (bcopy_libfunc, 0,
        !          2184:                             VOIDmode, 3, XEXP (xinner, 0), Pmode, temp, Pmode,
        !          2185:                             convert_to_mode (TYPE_MODE (sizetype),
        !          2186:                                              size, TREE_UNSIGNED (sizetype)),
        !          2187:                             TYPE_MODE (sizetype));
        !          2188: #endif
        !          2189:          OK_DEFER_POP;
        !          2190:        }
        !          2191:     }
        !          2192:   else if (partial > 0)
        !          2193:     {
        !          2194:       /* Scalar partly in registers.  */
        !          2195: 
        !          2196:       int size = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
        !          2197:       int i;
        !          2198:       int not_stack;
        !          2199:       /* # words of start of argument
        !          2200:         that we must make space for but need not store.  */
        !          2201:       int offset = partial % (PARM_BOUNDARY / BITS_PER_WORD);
        !          2202:       int args_offset = INTVAL (args_so_far);
        !          2203:       int skip;
        !          2204: 
        !          2205:       /* Push padding now if padding above and stack grows down,
        !          2206:         or if padding below and stack grows up.
        !          2207:         But if space already allocated, this has already been done.  */
        !          2208:       if (extra && args_addr == 0
        !          2209:          && where_pad != none && where_pad != stack_direction)
        !          2210:        anti_adjust_stack (GEN_INT (extra));
        !          2211: 
        !          2212:       /* If we make space by pushing it, we might as well push
        !          2213:         the real data.  Otherwise, we can leave OFFSET nonzero
        !          2214:         and leave the space uninitialized.  */
        !          2215:       if (args_addr == 0)
        !          2216:        offset = 0;
        !          2217: 
        !          2218:       /* Now NOT_STACK gets the number of words that we don't need to
        !          2219:         allocate on the stack.  */
        !          2220:       not_stack = partial - offset;
        !          2221: 
        !          2222:       /* If the partial register-part of the arg counts in its stack size,
        !          2223:         skip the part of stack space corresponding to the registers.
        !          2224:         Otherwise, start copying to the beginning of the stack space,
        !          2225:         by setting SKIP to 0.  */
        !          2226: #ifndef REG_PARM_STACK_SPACE
        !          2227:       skip = 0;
        !          2228: #else
        !          2229:       skip = not_stack;
        !          2230: #endif
        !          2231: 
        !          2232:       if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
        !          2233:        x = validize_mem (force_const_mem (mode, x));
        !          2234: 
        !          2235:       /* If X is a hard register in a non-integer mode, copy it into a pseudo;
        !          2236:         SUBREGs of such registers are not allowed.  */
        !          2237:       if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER
        !          2238:           && GET_MODE_CLASS (GET_MODE (x)) != MODE_INT))
        !          2239:        x = copy_to_reg (x);
        !          2240: 
        !          2241:       /* Loop over all the words allocated on the stack for this arg.  */
        !          2242:       /* We can do it by words, because any scalar bigger than a word
        !          2243:         has a size a multiple of a word.  */
        !          2244: #ifndef PUSH_ARGS_REVERSED
        !          2245:       for (i = not_stack; i < size; i++)
        !          2246: #else
        !          2247:       for (i = size - 1; i >= not_stack; i--)
        !          2248: #endif
        !          2249:        if (i >= not_stack + offset)
        !          2250:          emit_push_insn (operand_subword_force (x, i, mode),
        !          2251:                          word_mode, NULL_TREE, NULL_RTX, align, 0, NULL_RTX,
        !          2252:                          0, args_addr,
        !          2253:                          GEN_INT (args_offset + ((i - not_stack + skip)
        !          2254:                                                  * UNITS_PER_WORD)));
        !          2255:     }
        !          2256:   else
        !          2257:     {
        !          2258:       rtx addr;
        !          2259: 
        !          2260:       /* Push padding now if padding above and stack grows down,
        !          2261:         or if padding below and stack grows up.
        !          2262:         But if space already allocated, this has already been done.  */
        !          2263:       if (extra && args_addr == 0
        !          2264:          && where_pad != none && where_pad != stack_direction)
        !          2265:        anti_adjust_stack (GEN_INT (extra));
        !          2266: 
        !          2267: #ifdef PUSH_ROUNDING
        !          2268:       if (args_addr == 0)
        !          2269:        addr = gen_push_operand ();
        !          2270:       else
        !          2271: #endif
        !          2272:        if (GET_CODE (args_so_far) == CONST_INT)
        !          2273:          addr
        !          2274:            = memory_address (mode,
        !          2275:                              plus_constant (args_addr, INTVAL (args_so_far)));
        !          2276:       else
        !          2277:        addr = memory_address (mode, gen_rtx (PLUS, Pmode, args_addr,
        !          2278:                                              args_so_far));
        !          2279: 
        !          2280:       emit_move_insn (gen_rtx (MEM, mode, addr), x);
        !          2281:     }
        !          2282: 
        !          2283:  ret:
        !          2284:   /* If part should go in registers, copy that part
        !          2285:      into the appropriate registers.  Do this now, at the end,
        !          2286:      since mem-to-mem copies above may do function calls.  */
        !          2287:   if (partial > 0 && reg != 0)
        !          2288:     move_block_to_reg (REGNO (reg), x, partial, mode);
        !          2289: 
        !          2290:   if (extra && args_addr == 0 && where_pad == stack_direction)
        !          2291:     anti_adjust_stack (GEN_INT (extra));
        !          2292: }
        !          2293: 
        !          2294: /* Expand an assignment that stores the value of FROM into TO.
        !          2295:    If WANT_VALUE is nonzero, return an rtx for the value of TO.
        !          2296:    (This may contain a QUEUED rtx;
        !          2297:    if the value is constant, this rtx is a constant.)
        !          2298:    Otherwise, the returned value is NULL_RTX.
        !          2299: 
        !          2300:    SUGGEST_REG is no longer actually used.
        !          2301:    It used to mean, copy the value through a register
        !          2302:    and return that register, if that is possible.
        !          2303:    We now use WANT_VALUE to decide whether to do this.  */
        !          2304: 
        !          2305: rtx
        !          2306: expand_assignment (to, from, want_value, suggest_reg)
        !          2307:      tree to, from;
        !          2308:      int want_value;
        !          2309:      int suggest_reg;
        !          2310: {
        !          2311:   register rtx to_rtx = 0;
        !          2312:   rtx result;
        !          2313: 
        !          2314:   /* Don't crash if the lhs of the assignment was erroneous.  */
        !          2315: 
        !          2316:   if (TREE_CODE (to) == ERROR_MARK)
        !          2317:     {
        !          2318:       result = expand_expr (from, NULL_RTX, VOIDmode, 0);
        !          2319:       return want_value ? result : NULL_RTX;
        !          2320:     }
        !          2321: 
        !          2322:   if (output_bytecode)
        !          2323:     {
        !          2324:       tree dest_innermost;
        !          2325: 
        !          2326:       bc_expand_expr (from);
        !          2327:       bc_emit_instruction (duplicate);
        !          2328: 
        !          2329:       dest_innermost = bc_expand_address (to);
        !          2330: 
        !          2331:       /* Can't deduce from TYPE that we're dealing with a bitfield, so
        !          2332:         take care of it here. */
        !          2333: 
        !          2334:       bc_store_memory (TREE_TYPE (to), dest_innermost);
        !          2335:       return NULL;
        !          2336:     }
        !          2337: 
        !          2338:   /* Assignment of a structure component needs special treatment
        !          2339:      if the structure component's rtx is not simply a MEM.
        !          2340:      Assignment of an array element at a constant index
        !          2341:      has the same problem.  */
        !          2342: 
        !          2343:   if (TREE_CODE (to) == COMPONENT_REF
        !          2344:       || TREE_CODE (to) == BIT_FIELD_REF
        !          2345:       || (TREE_CODE (to) == ARRAY_REF
        !          2346:          && TREE_CODE (TREE_OPERAND (to, 1)) == INTEGER_CST
        !          2347:          && TREE_CODE (TYPE_SIZE (TREE_TYPE (to))) == INTEGER_CST))
        !          2348:     {
        !          2349:       enum machine_mode mode1;
        !          2350:       int bitsize;
        !          2351:       int bitpos;
        !          2352:       tree offset;
        !          2353:       int unsignedp;
        !          2354:       int volatilep = 0;
        !          2355:       tree tem;
        !          2356:       int alignment;
        !          2357: 
        !          2358:       push_temp_slots ();
        !          2359:       tem = get_inner_reference (to, &bitsize, &bitpos, &offset,
        !          2360:                                      &mode1, &unsignedp, &volatilep);
        !          2361: 
        !          2362:       /* If we are going to use store_bit_field and extract_bit_field,
        !          2363:         make sure to_rtx will be safe for multiple use.  */
        !          2364: 
        !          2365:       if (mode1 == VOIDmode && want_value)
        !          2366:        tem = stabilize_reference (tem);
        !          2367: 
        !          2368:       alignment = TYPE_ALIGN (TREE_TYPE (tem)) / BITS_PER_UNIT;
        !          2369:       to_rtx = expand_expr (tem, NULL_RTX, VOIDmode, 0);
        !          2370:       if (offset != 0)
        !          2371:        {
        !          2372:          rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
        !          2373: 
        !          2374:          if (GET_CODE (to_rtx) != MEM)
        !          2375:            abort ();
        !          2376:          to_rtx = change_address (to_rtx, VOIDmode,
        !          2377:                                   gen_rtx (PLUS, Pmode, XEXP (to_rtx, 0),
        !          2378:                                            force_reg (Pmode, offset_rtx)));
        !          2379:          /* If we have a variable offset, the known alignment
        !          2380:             is only that of the innermost structure containing the field.
        !          2381:             (Actually, we could sometimes do better by using the
        !          2382:             align of an element of the innermost array, but no need.)  */
        !          2383:          if (TREE_CODE (to) == COMPONENT_REF
        !          2384:              || TREE_CODE (to) == BIT_FIELD_REF)
        !          2385:            alignment
        !          2386:              = TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (to, 0))) / BITS_PER_UNIT;
        !          2387:        }
        !          2388:       if (volatilep)
        !          2389:        {
        !          2390:          if (GET_CODE (to_rtx) == MEM)
        !          2391:            MEM_VOLATILE_P (to_rtx) = 1;
        !          2392: #if 0  /* This was turned off because, when a field is volatile
        !          2393:          in an object which is not volatile, the object may be in a register,
        !          2394:          and then we would abort over here.  */
        !          2395:          else
        !          2396:            abort ();
        !          2397: #endif
        !          2398:        }
        !          2399: 
        !          2400: 
        !          2401:       /*
        !          2402:       if (TREE_SELF_OFFSET (TREE_OPERAND (to, 1)))
        !          2403:        {
        !          2404:          from = build_binary_op (MINUS_EXPR, from,
        !          2405:                                  build1 (ADDR_EXPR, TREE_TYPE (to), to));
        !          2406:        }
        !          2407: */
        !          2408: 
        !          2409:       result = store_field (to_rtx, bitsize, bitpos, mode1, from,
        !          2410:                            (want_value
        !          2411:                             /* Spurious cast makes HPUX compiler happy.  */
        !          2412:                             ? (enum machine_mode) TYPE_MODE (TREE_TYPE (to))
        !          2413:                             : VOIDmode),
        !          2414:                            unsignedp,
        !          2415:                            /* Required alignment of containing datum.  */
        !          2416:                            alignment,
        !          2417:                            int_size_in_bytes (TREE_TYPE (tem)));
        !          2418:       preserve_temp_slots (result);
        !          2419:       free_temp_slots ();
        !          2420:       pop_temp_slots ();
        !          2421: 
        !          2422:       /* If the value is meaningful, convert RESULT to the proper mode.
        !          2423:         Otherwise, return nothing.  */
        !          2424:       return (want_value ? convert_modes (TYPE_MODE (TREE_TYPE (to)),
        !          2425:                                          TYPE_MODE (TREE_TYPE (from)),
        !          2426:                                          result,
        !          2427:                                          TREE_UNSIGNED (TREE_TYPE (to)))
        !          2428:              : NULL_RTX);
        !          2429:     }
        !          2430: 
        !          2431:   /* If the rhs is a function call and its value is not an aggregate,
        !          2432:      call the function before we start to compute the lhs.
        !          2433:      This is needed for correct code for cases such as
        !          2434:      val = setjmp (buf) on machines where reference to val
        !          2435:      requires loading up part of an address in a separate insn.
        !          2436: 
        !          2437:      Don't do this if TO is a VAR_DECL whose DECL_RTL is REG since it might be
        !          2438:      a promoted variable where the zero- or sign- extension needs to be done.
        !          2439:      Handling this in the normal way is safe because no computation is done
        !          2440:      before the call.  */
        !          2441:   if (TREE_CODE (from) == CALL_EXPR && ! aggregate_value_p (from)
        !          2442:       && ! (TREE_CODE (to) == VAR_DECL && GET_CODE (DECL_RTL (to)) == REG))
        !          2443:     {
        !          2444:       rtx value;
        !          2445: 
        !          2446:       push_temp_slots ();
        !          2447:       value = expand_expr (from, NULL_RTX, VOIDmode, 0);
        !          2448:       if (to_rtx == 0)
        !          2449:        to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_CONST_ADDRESS);
        !          2450: 
        !          2451:       emit_move_insn (to_rtx, value);
        !          2452:       preserve_temp_slots (to_rtx);
        !          2453:       free_temp_slots ();
        !          2454:       pop_temp_slots ();
        !          2455:       return want_value ? to_rtx : NULL_RTX;
        !          2456:     }
        !          2457: 
        !          2458:   /* Ordinary treatment.  Expand TO to get a REG or MEM rtx.
        !          2459:      Don't re-expand if it was expanded already (in COMPONENT_REF case).  */
        !          2460: 
        !          2461:   if (to_rtx == 0)
        !          2462:     to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_CONST_ADDRESS);
        !          2463: 
        !          2464:   /*
        !          2465:   if (TREE_SELF_OFFSET (to))
        !          2466:     {
        !          2467:       from = build_binary_op (MINUS_EXPR, from,
        !          2468:                              build1 (ADDR_EXPR, TREE_TYPE (to), to));
        !          2469:     }
        !          2470:     */
        !          2471: 
        !          2472:   /* Don't move directly into a return register.  */
        !          2473:   if (TREE_CODE (to) == RESULT_DECL && GET_CODE (to_rtx) == REG)
        !          2474:     {
        !          2475:       rtx temp;
        !          2476: 
        !          2477:       push_temp_slots ();
        !          2478:       temp = expand_expr (from, 0, GET_MODE (to_rtx), 0);
        !          2479:       emit_move_insn (to_rtx, temp);
        !          2480:       preserve_temp_slots (to_rtx);
        !          2481:       free_temp_slots ();
        !          2482:       pop_temp_slots ();
        !          2483:       return want_value ? to_rtx : NULL_RTX;
        !          2484:     }
        !          2485: 
        !          2486:   /* In case we are returning the contents of an object which overlaps
        !          2487:      the place the value is being stored, use a safe function when copying
        !          2488:      a value through a pointer into a structure value return block.  */
        !          2489:   if (TREE_CODE (to) == RESULT_DECL && TREE_CODE (from) == INDIRECT_REF
        !          2490:       && current_function_returns_struct
        !          2491:       && !current_function_returns_pcc_struct)
        !          2492:     {
        !          2493:       rtx from_rtx, size;
        !          2494: 
        !          2495:       push_temp_slots ();
        !          2496:       size = expr_size (from);
        !          2497:       from_rtx = expand_expr (from, NULL_RTX, VOIDmode, 0);
        !          2498: 
        !          2499: #ifdef TARGET_MEM_FUNCTIONS
        !          2500:       emit_library_call (memcpy_libfunc, 0,
        !          2501:                         VOIDmode, 3, XEXP (to_rtx, 0), Pmode,
        !          2502:                         XEXP (from_rtx, 0), Pmode,
        !          2503:                         convert_to_mode (TYPE_MODE (sizetype),
        !          2504:                                          size, TREE_UNSIGNED (sizetype)),
        !          2505:                         TYPE_MODE (sizetype));
        !          2506: #else
        !          2507:       emit_library_call (bcopy_libfunc, 0,
        !          2508:                         VOIDmode, 3, XEXP (from_rtx, 0), Pmode,
        !          2509:                         XEXP (to_rtx, 0), Pmode,
        !          2510:                         convert_to_mode (TYPE_MODE (sizetype),
        !          2511:                                          size, TREE_UNSIGNED (sizetype)),
        !          2512:                         TYPE_MODE (sizetype));
        !          2513: #endif
        !          2514: 
        !          2515:       preserve_temp_slots (to_rtx);
        !          2516:       free_temp_slots ();
        !          2517:       pop_temp_slots ();
        !          2518:       return want_value ? to_rtx : NULL_RTX;
        !          2519:     }
        !          2520: 
        !          2521:   /* Compute FROM and store the value in the rtx we got.  */
        !          2522: 
        !          2523:   push_temp_slots ();
        !          2524:   result = store_expr (from, to_rtx, want_value);
        !          2525:   preserve_temp_slots (result);
        !          2526:   free_temp_slots ();
        !          2527:   pop_temp_slots ();
        !          2528:   return want_value ? result : NULL_RTX;
        !          2529: }
        !          2530: 
        !          2531: /* Generate code for computing expression EXP,
        !          2532:    and storing the value into TARGET.
        !          2533:    TARGET may contain a QUEUED rtx.
        !          2534: 
        !          2535:    If WANT_VALUE is nonzero, return a copy of the value
        !          2536:    not in TARGET, so that we can be sure to use the proper
        !          2537:    value in a containing expression even if TARGET has something
        !          2538:    else stored in it.  If possible, we copy the value through a pseudo
        !          2539:    and return that pseudo.  Or, if the value is constant, we try to
        !          2540:    return the constant.  In some cases, we return a pseudo
        !          2541:    copied *from* TARGET.
        !          2542: 
        !          2543:    If the mode is BLKmode then we may return TARGET itself.
        !          2544:    It turns out that in BLKmode it doesn't cause a problem.
        !          2545:    because C has no operators that could combine two different
        !          2546:    assignments into the same BLKmode object with different values
        !          2547:    with no sequence point.  Will other languages need this to
        !          2548:    be more thorough?
        !          2549: 
        !          2550:    If WANT_VALUE is 0, we return NULL, to make sure
        !          2551:    to catch quickly any cases where the caller uses the value
        !          2552:    and fails to set WANT_VALUE.  */
        !          2553: 
        !          2554: rtx
        !          2555: store_expr (exp, target, want_value)
        !          2556:      register tree exp;
        !          2557:      register rtx target;
        !          2558:      int want_value;
        !          2559: {
        !          2560:   register rtx temp;
        !          2561:   int dont_return_target = 0;
        !          2562: 
        !          2563:   if (TREE_CODE (exp) == COMPOUND_EXPR)
        !          2564:     {
        !          2565:       /* Perform first part of compound expression, then assign from second
        !          2566:         part.  */
        !          2567:       expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
        !          2568:       emit_queue ();
        !          2569:       return store_expr (TREE_OPERAND (exp, 1), target, want_value);
        !          2570:     }
        !          2571:   else if (TREE_CODE (exp) == COND_EXPR && GET_MODE (target) == BLKmode)
        !          2572:     {
        !          2573:       /* For conditional expression, get safe form of the target.  Then
        !          2574:         test the condition, doing the appropriate assignment on either
        !          2575:         side.  This avoids the creation of unnecessary temporaries.
        !          2576:         For non-BLKmode, it is more efficient not to do this.  */
        !          2577: 
        !          2578:       rtx lab1 = gen_label_rtx (), lab2 = gen_label_rtx ();
        !          2579: 
        !          2580:       emit_queue ();
        !          2581:       target = protect_from_queue (target, 1);
        !          2582: 
        !          2583:       NO_DEFER_POP;
        !          2584:       jumpifnot (TREE_OPERAND (exp, 0), lab1);
        !          2585:       store_expr (TREE_OPERAND (exp, 1), target, 0);
        !          2586:       emit_queue ();
        !          2587:       emit_jump_insn (gen_jump (lab2));
        !          2588:       emit_barrier ();
        !          2589:       emit_label (lab1);
        !          2590:       store_expr (TREE_OPERAND (exp, 2), target, 0);
        !          2591:       emit_queue ();
        !          2592:       emit_label (lab2);
        !          2593:       OK_DEFER_POP;
        !          2594:       return want_value ? target : NULL_RTX;
        !          2595:     }
        !          2596:   else if (want_value && GET_CODE (target) == MEM && ! MEM_VOLATILE_P (target)
        !          2597:           && GET_MODE (target) != BLKmode)
        !          2598:     /* If target is in memory and caller wants value in a register instead,
        !          2599:        arrange that.  Pass TARGET as target for expand_expr so that,
        !          2600:        if EXP is another assignment, WANT_VALUE will be nonzero for it.
        !          2601:        We know expand_expr will not use the target in that case.
        !          2602:        Don't do this if TARGET is volatile because we are supposed
        !          2603:        to write it and then read it.  */
        !          2604:     {
        !          2605:       temp = expand_expr (exp, cse_not_expected ? NULL_RTX : target,
        !          2606:                          GET_MODE (target), 0);
        !          2607:       if (GET_MODE (temp) != BLKmode && GET_MODE (temp) != VOIDmode)
        !          2608:        temp = copy_to_reg (temp);
        !          2609:       dont_return_target = 1;
        !          2610:     }
        !          2611:   else if (queued_subexp_p (target))
        !          2612:     /* If target contains a postincrement, let's not risk
        !          2613:        using it as the place to generate the rhs.  */
        !          2614:     {
        !          2615:       if (GET_MODE (target) != BLKmode && GET_MODE (target) != VOIDmode)
        !          2616:        {
        !          2617:          /* Expand EXP into a new pseudo.  */
        !          2618:          temp = gen_reg_rtx (GET_MODE (target));
        !          2619:          temp = expand_expr (exp, temp, GET_MODE (target), 0);
        !          2620:        }
        !          2621:       else
        !          2622:        temp = expand_expr (exp, NULL_RTX, GET_MODE (target), 0);
        !          2623: 
        !          2624:       /* If target is volatile, ANSI requires accessing the value
        !          2625:         *from* the target, if it is accessed.  So make that happen.
        !          2626:         In no case return the target itself.  */
        !          2627:       if (! MEM_VOLATILE_P (target) && want_value)
        !          2628:        dont_return_target = 1;
        !          2629:     }
        !          2630:   else if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
        !          2631:     /* If this is an scalar in a register that is stored in a wider mode
        !          2632:        than the declared mode, compute the result into its declared mode
        !          2633:        and then convert to the wider mode.  Our value is the computed
        !          2634:        expression.  */
        !          2635:     {
        !          2636:       temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
        !          2637: 
        !          2638:       /* If TEMP is a VOIDmode constant, use convert_modes to make
        !          2639:         sure that we properly convert it.  */
        !          2640:       if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
        !          2641:        temp = convert_modes (GET_MODE (SUBREG_REG (target)),
        !          2642:                              TYPE_MODE (TREE_TYPE (exp)), temp,
        !          2643:                              SUBREG_PROMOTED_UNSIGNED_P (target));
        !          2644: 
        !          2645:       convert_move (SUBREG_REG (target), temp,
        !          2646:                    SUBREG_PROMOTED_UNSIGNED_P (target));
        !          2647:       return want_value ? temp : NULL_RTX;
        !          2648:     }
        !          2649:   else
        !          2650:     {
        !          2651:       temp = expand_expr (exp, target, GET_MODE (target), 0);
        !          2652:       /* DO return TARGET if it's a specified hardware register.
        !          2653:         expand_return relies on this.
        !          2654:         If TARGET is a volatile mem ref, either return TARGET
        !          2655:         or return a reg copied *from* TARGET; ANSI requires this.
        !          2656: 
        !          2657:         Otherwise, if TEMP is not TARGET, return TEMP
        !          2658:         if it is constant (for efficiency),
        !          2659:         or if we really want the correct value.  */
        !          2660:       if (!(target && GET_CODE (target) == REG
        !          2661:            && REGNO (target) < FIRST_PSEUDO_REGISTER)
        !          2662:          && !(GET_CODE (target) == MEM && MEM_VOLATILE_P (target))
        !          2663:          && temp != target
        !          2664:          && (CONSTANT_P (temp) || want_value))
        !          2665:        dont_return_target = 1;
        !          2666:     }
        !          2667: 
        !          2668:   /* If TEMP is a VOIDmode constant and the mode of the type of EXP is not
        !          2669:      the same as that of TARGET, adjust the constant.  This is needed, for
        !          2670:      example, in case it is a CONST_DOUBLE and we want only a word-sized
        !          2671:      value.  */
        !          2672:   if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode
        !          2673:       && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
        !          2674:     temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
        !          2675:                          temp, TREE_UNSIGNED (TREE_TYPE (exp)));
        !          2676: 
        !          2677:   /* If value was not generated in the target, store it there.
        !          2678:      Convert the value to TARGET's type first if nec.  */
        !          2679: 
        !          2680:   if (temp != target && TREE_CODE (exp) != ERROR_MARK)
        !          2681:     {
        !          2682:       target = protect_from_queue (target, 1);
        !          2683:       if (GET_MODE (temp) != GET_MODE (target)
        !          2684:          && GET_MODE (temp) != VOIDmode)
        !          2685:        {
        !          2686:          int unsignedp = TREE_UNSIGNED (TREE_TYPE (exp));
        !          2687:          if (dont_return_target)
        !          2688:            {
        !          2689:              /* In this case, we will return TEMP,
        !          2690:                 so make sure it has the proper mode.
        !          2691:                 But don't forget to store the value into TARGET.  */
        !          2692:              temp = convert_to_mode (GET_MODE (target), temp, unsignedp);
        !          2693:              emit_move_insn (target, temp);
        !          2694:            }
        !          2695:          else
        !          2696:            convert_move (target, temp, unsignedp);
        !          2697:        }
        !          2698: 
        !          2699:       else if (GET_MODE (temp) == BLKmode && TREE_CODE (exp) == STRING_CST)
        !          2700:        {
        !          2701:          /* Handle copying a string constant into an array.
        !          2702:             The string constant may be shorter than the array.
        !          2703:             So copy just the string's actual length, and clear the rest.  */
        !          2704:          rtx size;
        !          2705: 
        !          2706:          /* Get the size of the data type of the string,
        !          2707:             which is actually the size of the target.  */
        !          2708:          size = expr_size (exp);
        !          2709:          if (GET_CODE (size) == CONST_INT
        !          2710:              && INTVAL (size) < TREE_STRING_LENGTH (exp))
        !          2711:            emit_block_move (target, temp, size,
        !          2712:                             TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
        !          2713:          else
        !          2714:            {
        !          2715:              /* Compute the size of the data to copy from the string.  */
        !          2716:              tree copy_size
        !          2717:                = size_binop (MIN_EXPR,
        !          2718:                              make_tree (sizetype, size),
        !          2719:                              convert (sizetype,
        !          2720:                                       build_int_2 (TREE_STRING_LENGTH (exp), 0)));
        !          2721:              rtx copy_size_rtx = expand_expr (copy_size, NULL_RTX,
        !          2722:                                               VOIDmode, 0);
        !          2723:              rtx label = 0;
        !          2724: 
        !          2725:              /* Copy that much.  */
        !          2726:              emit_block_move (target, temp, copy_size_rtx,
        !          2727:                               TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
        !          2728: 
        !          2729:              /* Figure out how much is left in TARGET
        !          2730:                 that we have to clear.  */
        !          2731:              if (GET_CODE (copy_size_rtx) == CONST_INT)
        !          2732:                {
        !          2733:                  temp = plus_constant (XEXP (target, 0),
        !          2734:                                        TREE_STRING_LENGTH (exp));
        !          2735:                  size = plus_constant (size,
        !          2736:                                        - TREE_STRING_LENGTH (exp));
        !          2737:                }
        !          2738:              else
        !          2739:                {
        !          2740:                  enum machine_mode size_mode = Pmode;
        !          2741: 
        !          2742:                  temp = force_reg (Pmode, XEXP (target, 0));
        !          2743:                  temp = expand_binop (size_mode, add_optab, temp,
        !          2744:                                       copy_size_rtx, NULL_RTX, 0,
        !          2745:                                       OPTAB_LIB_WIDEN);
        !          2746: 
        !          2747:                  size = expand_binop (size_mode, sub_optab, size,
        !          2748:                                       copy_size_rtx, NULL_RTX, 0,
        !          2749:                                       OPTAB_LIB_WIDEN);
        !          2750: 
        !          2751:                  emit_cmp_insn (size, const0_rtx, LT, NULL_RTX,
        !          2752:                                 GET_MODE (size), 0, 0);
        !          2753:                  label = gen_label_rtx ();
        !          2754:                  emit_jump_insn (gen_blt (label));
        !          2755:                }
        !          2756: 
        !          2757:              if (size != const0_rtx)
        !          2758:                {
        !          2759: #ifdef TARGET_MEM_FUNCTIONS
        !          2760:                  emit_library_call (memset_libfunc, 0, VOIDmode, 3,
        !          2761:                                     temp, Pmode, const0_rtx, Pmode, size, Pmode);
        !          2762: #else
        !          2763:                  emit_library_call (bzero_libfunc, 0, VOIDmode, 2,
        !          2764:                                     temp, Pmode, size, Pmode);
        !          2765: #endif
        !          2766:                }
        !          2767:              if (label)
        !          2768:                emit_label (label);
        !          2769:            }
        !          2770:        }
        !          2771:       else if (GET_MODE (temp) == BLKmode)
        !          2772:        emit_block_move (target, temp, expr_size (exp),
        !          2773:                         TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
        !          2774:       else
        !          2775:        emit_move_insn (target, temp);
        !          2776:     }
        !          2777: 
        !          2778:   if (dont_return_target && GET_CODE (temp) != MEM)
        !          2779:     return temp;
        !          2780:   if (want_value && GET_MODE (target) != BLKmode)
        !          2781:     return copy_to_reg (target);
        !          2782:   if (want_value)
        !          2783:     return target;
        !          2784:   return NULL_RTX;
        !          2785: }
        !          2786: 
        !          2787: /* Store the value of constructor EXP into the rtx TARGET.
        !          2788:    TARGET is either a REG or a MEM.  */
        !          2789: 
        !          2790: static void
        !          2791: store_constructor (exp, target)
        !          2792:      tree exp;
        !          2793:      rtx target;
        !          2794: {
        !          2795:   tree type = TREE_TYPE (exp);
        !          2796: 
        !          2797:   /* We know our target cannot conflict, since safe_from_p has been called.  */
        !          2798: #if 0
        !          2799:   /* Don't try copying piece by piece into a hard register
        !          2800:      since that is vulnerable to being clobbered by EXP.
        !          2801:      Instead, construct in a pseudo register and then copy it all.  */
        !          2802:   if (GET_CODE (target) == REG && REGNO (target) < FIRST_PSEUDO_REGISTER)
        !          2803:     {
        !          2804:       rtx temp = gen_reg_rtx (GET_MODE (target));
        !          2805:       store_constructor (exp, temp);
        !          2806:       emit_move_insn (target, temp);
        !          2807:       return;
        !          2808:     }
        !          2809: #endif
        !          2810: 
        !          2811:   if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
        !          2812:       || TREE_CODE (type) == QUAL_UNION_TYPE)
        !          2813:     {
        !          2814:       register tree elt;
        !          2815: 
        !          2816:       /* Inform later passes that the whole union value is dead.  */
        !          2817:       if (TREE_CODE (type) == UNION_TYPE
        !          2818:          || TREE_CODE (type) == QUAL_UNION_TYPE)
        !          2819:        emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
        !          2820: 
        !          2821:       /* If we are building a static constructor into a register,
        !          2822:         set the initial value as zero so we can fold the value into
        !          2823:         a constant.  */
        !          2824:       else if (GET_CODE (target) == REG && TREE_STATIC (exp))
        !          2825:        emit_move_insn (target, const0_rtx);
        !          2826: 
        !          2827:       /* If the constructor has fewer fields than the structure,
        !          2828:         clear the whole structure first.  */
        !          2829:       else if (list_length (CONSTRUCTOR_ELTS (exp))
        !          2830:               != list_length (TYPE_FIELDS (type)))
        !          2831:        clear_storage (target, int_size_in_bytes (type));
        !          2832:       else
        !          2833:        /* Inform later passes that the old value is dead.  */
        !          2834:        emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
        !          2835: 
        !          2836:       /* Store each element of the constructor into
        !          2837:         the corresponding field of TARGET.  */
        !          2838: 
        !          2839:       for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
        !          2840:        {
        !          2841:          register tree field = TREE_PURPOSE (elt);
        !          2842:          register enum machine_mode mode;
        !          2843:          int bitsize;
        !          2844:          int bitpos = 0;
        !          2845:          int unsignedp;
        !          2846:          tree pos, constant = 0, offset = 0;
        !          2847:          rtx to_rtx = target;
        !          2848: 
        !          2849:          /* Just ignore missing fields.
        !          2850:             We cleared the whole structure, above,
        !          2851:             if any fields are missing.  */
        !          2852:          if (field == 0)
        !          2853:            continue;
        !          2854: 
        !          2855:          bitsize = TREE_INT_CST_LOW (DECL_SIZE (field));
        !          2856:          unsignedp = TREE_UNSIGNED (field);
        !          2857:          mode = DECL_MODE (field);
        !          2858:          if (DECL_BIT_FIELD (field))
        !          2859:            mode = VOIDmode;
        !          2860: 
        !          2861:          pos = DECL_FIELD_BITPOS (field);
        !          2862:          if (TREE_CODE (pos) == INTEGER_CST)
        !          2863:            constant = pos;
        !          2864:          else if (TREE_CODE (pos) == PLUS_EXPR
        !          2865:                   && TREE_CODE (TREE_OPERAND (pos, 1)) == INTEGER_CST)
        !          2866:            constant = TREE_OPERAND (pos, 1), offset = TREE_OPERAND (pos, 0);
        !          2867:          else
        !          2868:            offset = pos;
        !          2869: 
        !          2870:          if (constant)
        !          2871:            bitpos = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field));
        !          2872: 
        !          2873:          if (offset)
        !          2874:            {
        !          2875:              rtx offset_rtx;
        !          2876: 
        !          2877:              if (contains_placeholder_p (offset))
        !          2878:                offset = build (WITH_RECORD_EXPR, sizetype,
        !          2879:                                offset, exp);
        !          2880: 
        !          2881:              offset = size_binop (FLOOR_DIV_EXPR, offset,
        !          2882:                                   size_int (BITS_PER_UNIT));
        !          2883: 
        !          2884:              offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
        !          2885:              if (GET_CODE (to_rtx) != MEM)
        !          2886:                abort ();
        !          2887: 
        !          2888:              to_rtx
        !          2889:                = change_address (to_rtx, VOIDmode,
        !          2890:                                  gen_rtx (PLUS, Pmode, XEXP (to_rtx, 0),
        !          2891:                                           force_reg (Pmode, offset_rtx)));
        !          2892:            }
        !          2893: 
        !          2894:          store_field (to_rtx, bitsize, bitpos, mode, TREE_VALUE (elt),
        !          2895:                       /* The alignment of TARGET is
        !          2896:                          at least what its type requires.  */
        !          2897:                       VOIDmode, 0,
        !          2898:                       TYPE_ALIGN (type) / BITS_PER_UNIT,
        !          2899:                       int_size_in_bytes (type));
        !          2900:        }
        !          2901:     }
        !          2902:   else if (TREE_CODE (type) == ARRAY_TYPE)
        !          2903:     {
        !          2904:       register tree elt;
        !          2905:       register int i;
        !          2906:       tree domain = TYPE_DOMAIN (type);
        !          2907:       HOST_WIDE_INT minelt = TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain));
        !          2908:       HOST_WIDE_INT maxelt = TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain));
        !          2909:       tree elttype = TREE_TYPE (type);
        !          2910: 
        !          2911:       /* If the constructor has fewer fields than the structure,
        !          2912:         clear the whole structure first.  Similarly if this this is
        !          2913:         static constructor of a non-BLKmode object.  */
        !          2914: 
        !          2915:       if (list_length (CONSTRUCTOR_ELTS (exp)) < maxelt - minelt + 1
        !          2916:          || (GET_CODE (target) == REG && TREE_STATIC (exp)))
        !          2917:        clear_storage (target, int_size_in_bytes (type));
        !          2918:       else
        !          2919:        /* Inform later passes that the old value is dead.  */
        !          2920:        emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
        !          2921: 
        !          2922:       /* Store each element of the constructor into
        !          2923:         the corresponding element of TARGET, determined
        !          2924:         by counting the elements.  */
        !          2925:       for (elt = CONSTRUCTOR_ELTS (exp), i = 0;
        !          2926:           elt;
        !          2927:           elt = TREE_CHAIN (elt), i++)
        !          2928:        {
        !          2929:          register enum machine_mode mode;
        !          2930:          int bitsize;
        !          2931:          int bitpos;
        !          2932:          int unsignedp;
        !          2933:          tree index = TREE_PURPOSE (elt);
        !          2934:          rtx xtarget = target;
        !          2935: 
        !          2936:          mode = TYPE_MODE (elttype);
        !          2937:          bitsize = GET_MODE_BITSIZE (mode);
        !          2938:          unsignedp = TREE_UNSIGNED (elttype);
        !          2939: 
        !          2940:          if (index != 0 && TREE_CODE (index) != INTEGER_CST)
        !          2941:            {
        !          2942:              /* We don't currently allow variable indices in a
        !          2943:                 C initializer, but let's try here to support them.  */
        !          2944:              rtx pos_rtx, addr, xtarget;
        !          2945:              tree position;
        !          2946: 
        !          2947:              position = size_binop (MULT_EXPR, index, TYPE_SIZE (elttype));
        !          2948:              pos_rtx = expand_expr (position, 0, VOIDmode, 0);
        !          2949:              addr = gen_rtx (PLUS, Pmode, XEXP (target, 0), pos_rtx);
        !          2950:              xtarget = change_address (target, mode, addr);
        !          2951:              store_expr (TREE_VALUE (elt), xtarget, 0);
        !          2952:            }
        !          2953:          else
        !          2954:            {
        !          2955:              if (index != 0)
        !          2956:                bitpos = ((TREE_INT_CST_LOW (index) - minelt)
        !          2957:                          * TREE_INT_CST_LOW (TYPE_SIZE (elttype)));
        !          2958:              else
        !          2959:                bitpos = (i * TREE_INT_CST_LOW (TYPE_SIZE (elttype)));
        !          2960: 
        !          2961:              store_field (xtarget, bitsize, bitpos, mode, TREE_VALUE (elt),
        !          2962:                           /* The alignment of TARGET is
        !          2963:                              at least what its type requires.  */
        !          2964:                           VOIDmode, 0,
        !          2965:                           TYPE_ALIGN (type) / BITS_PER_UNIT,
        !          2966:                           int_size_in_bytes (type));
        !          2967:            }
        !          2968:        }
        !          2969:     }
        !          2970: 
        !          2971:   else
        !          2972:     abort ();
        !          2973: }
        !          2974: 
        !          2975: /* Store the value of EXP (an expression tree)
        !          2976:    into a subfield of TARGET which has mode MODE and occupies
        !          2977:    BITSIZE bits, starting BITPOS bits from the start of TARGET.
        !          2978:    If MODE is VOIDmode, it means that we are storing into a bit-field.
        !          2979: 
        !          2980:    If VALUE_MODE is VOIDmode, return nothing in particular.
        !          2981:    UNSIGNEDP is not used in this case.
        !          2982: 
        !          2983:    Otherwise, return an rtx for the value stored.  This rtx
        !          2984:    has mode VALUE_MODE if that is convenient to do.
        !          2985:    In this case, UNSIGNEDP must be nonzero if the value is an unsigned type.
        !          2986: 
        !          2987:    ALIGN is the alignment that TARGET is known to have, measured in bytes.
        !          2988:    TOTAL_SIZE is the size in bytes of the structure, or -1 if varying.  */
        !          2989: 
        !          2990: static rtx
        !          2991: store_field (target, bitsize, bitpos, mode, exp, value_mode,
        !          2992:             unsignedp, align, total_size)
        !          2993:      rtx target;
        !          2994:      int bitsize, bitpos;
        !          2995:      enum machine_mode mode;
        !          2996:      tree exp;
        !          2997:      enum machine_mode value_mode;
        !          2998:      int unsignedp;
        !          2999:      int align;
        !          3000:      int total_size;
        !          3001: {
        !          3002:   HOST_WIDE_INT width_mask = 0;
        !          3003: 
        !          3004:   if (bitsize < HOST_BITS_PER_WIDE_INT)
        !          3005:     width_mask = ((HOST_WIDE_INT) 1 << bitsize) - 1;
        !          3006: 
        !          3007:   /* If we are storing into an unaligned field of an aligned union that is
        !          3008:      in a register, we may have the mode of TARGET being an integer mode but
        !          3009:      MODE == BLKmode.  In that case, get an aligned object whose size and
        !          3010:      alignment are the same as TARGET and store TARGET into it (we can avoid
        !          3011:      the store if the field being stored is the entire width of TARGET).  Then
        !          3012:      call ourselves recursively to store the field into a BLKmode version of
        !          3013:      that object.  Finally, load from the object into TARGET.  This is not
        !          3014:      very efficient in general, but should only be slightly more expensive
        !          3015:      than the otherwise-required unaligned accesses.  Perhaps this can be
        !          3016:      cleaned up later.  */
        !          3017: 
        !          3018:   if (mode == BLKmode
        !          3019:       && (GET_CODE (target) == REG || GET_CODE (target) == SUBREG))
        !          3020:     {
        !          3021:       rtx object = assign_stack_temp (GET_MODE (target),
        !          3022:                                      GET_MODE_SIZE (GET_MODE (target)), 0);
        !          3023:       rtx blk_object = copy_rtx (object);
        !          3024: 
        !          3025:       PUT_MODE (blk_object, BLKmode);
        !          3026: 
        !          3027:       if (bitsize != GET_MODE_BITSIZE (GET_MODE (target)))
        !          3028:        emit_move_insn (object, target);
        !          3029: 
        !          3030:       store_field (blk_object, bitsize, bitpos, mode, exp, VOIDmode, 0,
        !          3031:                   align, total_size);
        !          3032: 
        !          3033:       /* Even though we aren't returning target, we need to
        !          3034:         give it the updated value.  */
        !          3035:       emit_move_insn (target, object);
        !          3036: 
        !          3037:       return blk_object;
        !          3038:     }
        !          3039: 
        !          3040:   /* If the structure is in a register or if the component
        !          3041:      is a bit field, we cannot use addressing to access it.
        !          3042:      Use bit-field techniques or SUBREG to store in it.  */
        !          3043: 
        !          3044:   if (mode == VOIDmode
        !          3045:       || (mode != BLKmode && ! direct_store[(int) mode])
        !          3046:       || GET_CODE (target) == REG
        !          3047:       || GET_CODE (target) == SUBREG
        !          3048:       /* If the field isn't aligned enough to store as an ordinary memref,
        !          3049:         store it as a bit field.  */
        !          3050:       || (STRICT_ALIGNMENT
        !          3051:          && align * BITS_PER_UNIT < GET_MODE_ALIGNMENT (mode))
        !          3052:       || (STRICT_ALIGNMENT && bitpos % GET_MODE_ALIGNMENT (mode) != 0))
        !          3053:     {
        !          3054:       rtx temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
        !          3055: 
        !          3056:       /* Unless MODE is VOIDmode or BLKmode, convert TEMP to
        !          3057:         MODE.  */
        !          3058:       if (mode != VOIDmode && mode != BLKmode
        !          3059:          && mode != TYPE_MODE (TREE_TYPE (exp)))
        !          3060:        temp = convert_modes (mode, TYPE_MODE (TREE_TYPE (exp)), temp, 1);
        !          3061: 
        !          3062:       /* Store the value in the bitfield.  */
        !          3063:       store_bit_field (target, bitsize, bitpos, mode, temp, align, total_size);
        !          3064:       if (value_mode != VOIDmode)
        !          3065:        {
        !          3066:          /* The caller wants an rtx for the value.  */
        !          3067:          /* If possible, avoid refetching from the bitfield itself.  */
        !          3068:          if (width_mask != 0
        !          3069:              && ! (GET_CODE (target) == MEM && MEM_VOLATILE_P (target)))
        !          3070:            {
        !          3071:              tree count;
        !          3072:              enum machine_mode tmode;
        !          3073: 
        !          3074:              if (unsignedp)
        !          3075:                return expand_and (temp, GEN_INT (width_mask), NULL_RTX);
        !          3076:              tmode = GET_MODE (temp);
        !          3077:              if (tmode == VOIDmode)
        !          3078:                tmode = value_mode;
        !          3079:              count = build_int_2 (GET_MODE_BITSIZE (tmode) - bitsize, 0);
        !          3080:              temp = expand_shift (LSHIFT_EXPR, tmode, temp, count, 0, 0);
        !          3081:              return expand_shift (RSHIFT_EXPR, tmode, temp, count, 0, 0);
        !          3082:            }
        !          3083:          return extract_bit_field (target, bitsize, bitpos, unsignedp,
        !          3084:                                    NULL_RTX, value_mode, 0, align,
        !          3085:                                    total_size);
        !          3086:        }
        !          3087:       return const0_rtx;
        !          3088:     }
        !          3089:   else
        !          3090:     {
        !          3091:       rtx addr = XEXP (target, 0);
        !          3092:       rtx to_rtx;
        !          3093: 
        !          3094:       /* If a value is wanted, it must be the lhs;
        !          3095:         so make the address stable for multiple use.  */
        !          3096: 
        !          3097:       if (value_mode != VOIDmode && GET_CODE (addr) != REG
        !          3098:          && ! CONSTANT_ADDRESS_P (addr)
        !          3099:          /* A frame-pointer reference is already stable.  */
        !          3100:          && ! (GET_CODE (addr) == PLUS
        !          3101:                && GET_CODE (XEXP (addr, 1)) == CONST_INT
        !          3102:                && (XEXP (addr, 0) == virtual_incoming_args_rtx
        !          3103:                    || XEXP (addr, 0) == virtual_stack_vars_rtx)))
        !          3104:        addr = copy_to_reg (addr);
        !          3105: 
        !          3106:       /* Now build a reference to just the desired component.  */
        !          3107: 
        !          3108:       to_rtx = change_address (target, mode,
        !          3109:                               plus_constant (addr, (bitpos / BITS_PER_UNIT)));
        !          3110:       MEM_IN_STRUCT_P (to_rtx) = 1;
        !          3111: 
        !          3112:       return store_expr (exp, to_rtx, value_mode != VOIDmode);
        !          3113:     }
        !          3114: }
        !          3115: 
        !          3116: /* Given an expression EXP that may be a COMPONENT_REF, a BIT_FIELD_REF,
        !          3117:    or an ARRAY_REF, look for nested COMPONENT_REFs, BIT_FIELD_REFs, or
        !          3118:    ARRAY_REFs and find the ultimate containing object, which we return.
        !          3119: 
        !          3120:    We set *PBITSIZE to the size in bits that we want, *PBITPOS to the
        !          3121:    bit position, and *PUNSIGNEDP to the signedness of the field.
        !          3122:    If the position of the field is variable, we store a tree
        !          3123:    giving the variable offset (in units) in *POFFSET.
        !          3124:    This offset is in addition to the bit position.
        !          3125:    If the position is not variable, we store 0 in *POFFSET.
        !          3126: 
        !          3127:    If any of the extraction expressions is volatile,
        !          3128:    we store 1 in *PVOLATILEP.  Otherwise we don't change that.
        !          3129: 
        !          3130:    If the field is a bit-field, *PMODE is set to VOIDmode.  Otherwise, it
        !          3131:    is a mode that can be used to access the field.  In that case, *PBITSIZE
        !          3132:    is redundant.
        !          3133: 
        !          3134:    If the field describes a variable-sized object, *PMODE is set to
        !          3135:    VOIDmode and *PBITSIZE is set to -1.  An access cannot be made in
        !          3136:    this case, but the address of the object can be found.  */
        !          3137: 
        !          3138: tree
        !          3139: get_inner_reference (exp, pbitsize, pbitpos, poffset, pmode,
        !          3140:                     punsignedp, pvolatilep)
        !          3141:      tree exp;
        !          3142:      int *pbitsize;
        !          3143:      int *pbitpos;
        !          3144:      tree *poffset;
        !          3145:      enum machine_mode *pmode;
        !          3146:      int *punsignedp;
        !          3147:      int *pvolatilep;
        !          3148: {
        !          3149:   tree orig_exp = exp;
        !          3150:   tree size_tree = 0;
        !          3151:   enum machine_mode mode = VOIDmode;
        !          3152:   tree offset = integer_zero_node;
        !          3153: 
        !          3154:   if (TREE_CODE (exp) == COMPONENT_REF)
        !          3155:     {
        !          3156:       size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
        !          3157:       if (! DECL_BIT_FIELD (TREE_OPERAND (exp, 1)))
        !          3158:        mode = DECL_MODE (TREE_OPERAND (exp, 1));
        !          3159:       *punsignedp = TREE_UNSIGNED (TREE_OPERAND (exp, 1));
        !          3160:     }
        !          3161:   else if (TREE_CODE (exp) == BIT_FIELD_REF)
        !          3162:     {
        !          3163:       size_tree = TREE_OPERAND (exp, 1);
        !          3164:       *punsignedp = TREE_UNSIGNED (exp);
        !          3165:     }
        !          3166:   else
        !          3167:     {
        !          3168:       mode = TYPE_MODE (TREE_TYPE (exp));
        !          3169:       *pbitsize = GET_MODE_BITSIZE (mode);
        !          3170:       *punsignedp = TREE_UNSIGNED (TREE_TYPE (exp));
        !          3171:     }
        !          3172:       
        !          3173:   if (size_tree)
        !          3174:     {
        !          3175:       if (TREE_CODE (size_tree) != INTEGER_CST)
        !          3176:        mode = BLKmode, *pbitsize = -1;
        !          3177:       else
        !          3178:        *pbitsize = TREE_INT_CST_LOW (size_tree);
        !          3179:     }
        !          3180: 
        !          3181:   /* Compute cumulative bit-offset for nested component-refs and array-refs,
        !          3182:      and find the ultimate containing object.  */
        !          3183: 
        !          3184:   *pbitpos = 0;
        !          3185: 
        !          3186:   while (1)
        !          3187:     {
        !          3188:       if (TREE_CODE (exp) == COMPONENT_REF || TREE_CODE (exp) == BIT_FIELD_REF)
        !          3189:        {
        !          3190:          tree pos = (TREE_CODE (exp) == COMPONENT_REF
        !          3191:                      ? DECL_FIELD_BITPOS (TREE_OPERAND (exp, 1))
        !          3192:                      : TREE_OPERAND (exp, 2));
        !          3193: 
        !          3194:          /* If this field hasn't been filled in yet, don't go
        !          3195:             past it.  This should only happen when folding expressions
        !          3196:             made during type construction.  */
        !          3197:          if (pos == 0)
        !          3198:            break;
        !          3199: 
        !          3200:          if (TREE_CODE (pos) == PLUS_EXPR)
        !          3201:            {
        !          3202:              tree constant, var;
        !          3203:              if (TREE_CODE (TREE_OPERAND (pos, 0)) == INTEGER_CST)
        !          3204:                {
        !          3205:                  constant = TREE_OPERAND (pos, 0);
        !          3206:                  var = TREE_OPERAND (pos, 1);
        !          3207:                }
        !          3208:              else if (TREE_CODE (TREE_OPERAND (pos, 1)) == INTEGER_CST)
        !          3209:                {
        !          3210:                  constant = TREE_OPERAND (pos, 1);
        !          3211:                  var = TREE_OPERAND (pos, 0);
        !          3212:                }
        !          3213:              else
        !          3214:                abort ();
        !          3215: 
        !          3216:              *pbitpos += TREE_INT_CST_LOW (constant);
        !          3217:              offset = size_binop (PLUS_EXPR, offset,
        !          3218:                                   size_binop (FLOOR_DIV_EXPR, var,
        !          3219:                                               size_int (BITS_PER_UNIT)));
        !          3220:            }
        !          3221:          else if (TREE_CODE (pos) == INTEGER_CST)
        !          3222:            *pbitpos += TREE_INT_CST_LOW (pos);
        !          3223:          else
        !          3224:            {
        !          3225:              /* Assume here that the offset is a multiple of a unit.
        !          3226:                 If not, there should be an explicitly added constant.  */
        !          3227:              offset = size_binop (PLUS_EXPR, offset,
        !          3228:                                   size_binop (FLOOR_DIV_EXPR, pos,
        !          3229:                                               size_int (BITS_PER_UNIT)));
        !          3230:            }
        !          3231:        }
        !          3232: 
        !          3233:       else if (TREE_CODE (exp) == ARRAY_REF)
        !          3234:        {
        !          3235:          /* This code is based on the code in case ARRAY_REF in expand_expr
        !          3236:             below.  We assume here that the size of an array element is
        !          3237:             always an integral multiple of BITS_PER_UNIT.  */
        !          3238: 
        !          3239:          tree index = TREE_OPERAND (exp, 1);
        !          3240:          tree domain = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0)));
        !          3241:          tree low_bound
        !          3242:            = domain ? TYPE_MIN_VALUE (domain) : integer_zero_node;
        !          3243:          tree index_type = TREE_TYPE (index);
        !          3244: 
        !          3245:          if (! integer_zerop (low_bound))
        !          3246:            index = fold (build (MINUS_EXPR, index_type, index, low_bound));
        !          3247: 
        !          3248:          if (TYPE_PRECISION (index_type) != POINTER_SIZE)
        !          3249:            {
        !          3250:              index = convert (type_for_size (POINTER_SIZE, 0), index);
        !          3251:              index_type = TREE_TYPE (index);
        !          3252:            }
        !          3253: 
        !          3254:          index = fold (build (MULT_EXPR, index_type, index,
        !          3255:                               TYPE_SIZE (TREE_TYPE (exp))));
        !          3256: 
        !          3257:          if (TREE_CODE (index) == INTEGER_CST
        !          3258:              && TREE_INT_CST_HIGH (index) == 0)
        !          3259:            *pbitpos += TREE_INT_CST_LOW (index);
        !          3260:          else
        !          3261:            offset = size_binop (PLUS_EXPR, offset,
        !          3262:                                 size_binop (FLOOR_DIV_EXPR, index,
        !          3263:                                             size_int (BITS_PER_UNIT)));
        !          3264:        }
        !          3265:       else if (TREE_CODE (exp) != NON_LVALUE_EXPR
        !          3266:               && ! ((TREE_CODE (exp) == NOP_EXPR
        !          3267:                      || TREE_CODE (exp) == CONVERT_EXPR)
        !          3268:                     && (TYPE_MODE (TREE_TYPE (exp))
        !          3269:                         == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))))
        !          3270:        break;
        !          3271: 
        !          3272:       /* If any reference in the chain is volatile, the effect is volatile.  */
        !          3273:       if (TREE_THIS_VOLATILE (exp))
        !          3274:        *pvolatilep = 1;
        !          3275:       exp = TREE_OPERAND (exp, 0);
        !          3276:     }
        !          3277: 
        !          3278:   /* If this was a bit-field, see if there is a mode that allows direct
        !          3279:      access in case EXP is in memory.  */
        !          3280:   if (mode == VOIDmode && *pbitsize != 0 && *pbitpos % *pbitsize == 0)
        !          3281:     {
        !          3282:       mode = mode_for_size (*pbitsize, MODE_INT, 0);
        !          3283:       if (mode == BLKmode)
        !          3284:        mode = VOIDmode;
        !          3285:     }
        !          3286: 
        !          3287:   if (integer_zerop (offset))
        !          3288:     offset = 0;
        !          3289: 
        !          3290:   if (offset != 0 && contains_placeholder_p (offset))
        !          3291:     offset = build (WITH_RECORD_EXPR, sizetype, offset, orig_exp);
        !          3292: 
        !          3293:   *pmode = mode;
        !          3294:   *poffset = offset;
        !          3295:   return exp;
        !          3296: }
        !          3297: 
        !          3298: /* Given an rtx VALUE that may contain additions and multiplications,
        !          3299:    return an equivalent value that just refers to a register or memory.
        !          3300:    This is done by generating instructions to perform the arithmetic
        !          3301:    and returning a pseudo-register containing the value.
        !          3302: 
        !          3303:    The returned value may be a REG, SUBREG, MEM or constant.  */
        !          3304: 
        !          3305: rtx
        !          3306: force_operand (value, target)
        !          3307:      rtx value, target;
        !          3308: {
        !          3309:   register optab binoptab = 0;
        !          3310:   /* Use a temporary to force order of execution of calls to
        !          3311:      `force_operand'.  */
        !          3312:   rtx tmp;
        !          3313:   register rtx op2;
        !          3314:   /* Use subtarget as the target for operand 0 of a binary operation.  */
        !          3315:   register rtx subtarget = (target != 0 && GET_CODE (target) == REG ? target : 0);
        !          3316: 
        !          3317:   if (GET_CODE (value) == PLUS)
        !          3318:     binoptab = add_optab;
        !          3319:   else if (GET_CODE (value) == MINUS)
        !          3320:     binoptab = sub_optab;
        !          3321:   else if (GET_CODE (value) == MULT)
        !          3322:     {
        !          3323:       op2 = XEXP (value, 1);
        !          3324:       if (!CONSTANT_P (op2)
        !          3325:          && !(GET_CODE (op2) == REG && op2 != subtarget))
        !          3326:        subtarget = 0;
        !          3327:       tmp = force_operand (XEXP (value, 0), subtarget);
        !          3328:       return expand_mult (GET_MODE (value), tmp,
        !          3329:                          force_operand (op2, NULL_RTX),
        !          3330:                          target, 0);
        !          3331:     }
        !          3332: 
        !          3333:   if (binoptab)
        !          3334:     {
        !          3335:       op2 = XEXP (value, 1);
        !          3336:       if (!CONSTANT_P (op2)
        !          3337:          && !(GET_CODE (op2) == REG && op2 != subtarget))
        !          3338:        subtarget = 0;
        !          3339:       if (binoptab == sub_optab && GET_CODE (op2) == CONST_INT)
        !          3340:        {
        !          3341:          binoptab = add_optab;
        !          3342:          op2 = negate_rtx (GET_MODE (value), op2);
        !          3343:        }
        !          3344: 
        !          3345:       /* Check for an addition with OP2 a constant integer and our first
        !          3346:         operand a PLUS of a virtual register and something else.  In that
        !          3347:         case, we want to emit the sum of the virtual register and the
        !          3348:         constant first and then add the other value.  This allows virtual
        !          3349:         register instantiation to simply modify the constant rather than
        !          3350:         creating another one around this addition.  */
        !          3351:       if (binoptab == add_optab && GET_CODE (op2) == CONST_INT
        !          3352:          && GET_CODE (XEXP (value, 0)) == PLUS
        !          3353:          && GET_CODE (XEXP (XEXP (value, 0), 0)) == REG
        !          3354:          && REGNO (XEXP (XEXP (value, 0), 0)) >= FIRST_VIRTUAL_REGISTER
        !          3355:          && REGNO (XEXP (XEXP (value, 0), 0)) <= LAST_VIRTUAL_REGISTER)
        !          3356:        {
        !          3357:          rtx temp = expand_binop (GET_MODE (value), binoptab,
        !          3358:                                   XEXP (XEXP (value, 0), 0), op2,
        !          3359:                                   subtarget, 0, OPTAB_LIB_WIDEN);
        !          3360:          return expand_binop (GET_MODE (value), binoptab, temp,
        !          3361:                               force_operand (XEXP (XEXP (value, 0), 1), 0),
        !          3362:                               target, 0, OPTAB_LIB_WIDEN);
        !          3363:        }
        !          3364:                                   
        !          3365:       tmp = force_operand (XEXP (value, 0), subtarget);
        !          3366:       return expand_binop (GET_MODE (value), binoptab, tmp,
        !          3367:                           force_operand (op2, NULL_RTX),
        !          3368:                           target, 0, OPTAB_LIB_WIDEN);
        !          3369:       /* We give UNSIGNEDP = 0 to expand_binop
        !          3370:         because the only operations we are expanding here are signed ones.  */
        !          3371:     }
        !          3372:   return value;
        !          3373: }
        !          3374: 
        !          3375: /* Subroutine of expand_expr:
        !          3376:    save the non-copied parts (LIST) of an expr (LHS), and return a list
        !          3377:    which can restore these values to their previous values,
        !          3378:    should something modify their storage.  */
        !          3379: 
        !          3380: static tree
        !          3381: save_noncopied_parts (lhs, list)
        !          3382:      tree lhs;
        !          3383:      tree list;
        !          3384: {
        !          3385:   tree tail;
        !          3386:   tree parts = 0;
        !          3387: 
        !          3388:   for (tail = list; tail; tail = TREE_CHAIN (tail))
        !          3389:     if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
        !          3390:       parts = chainon (parts, save_noncopied_parts (lhs, TREE_VALUE (tail)));
        !          3391:     else
        !          3392:       {
        !          3393:        tree part = TREE_VALUE (tail);
        !          3394:        tree part_type = TREE_TYPE (part);
        !          3395:        tree to_be_saved = build (COMPONENT_REF, part_type, lhs, part);
        !          3396:        rtx target = assign_stack_temp (TYPE_MODE (part_type),
        !          3397:                                        int_size_in_bytes (part_type), 0);
        !          3398:        if (! memory_address_p (TYPE_MODE (part_type), XEXP (target, 0)))
        !          3399:          target = change_address (target, TYPE_MODE (part_type), NULL_RTX);
        !          3400:        parts = tree_cons (to_be_saved,
        !          3401:                           build (RTL_EXPR, part_type, NULL_TREE,
        !          3402:                                  (tree) target),
        !          3403:                           parts);
        !          3404:        store_expr (TREE_PURPOSE (parts), RTL_EXPR_RTL (TREE_VALUE (parts)), 0);
        !          3405:       }
        !          3406:   return parts;
        !          3407: }
        !          3408: 
        !          3409: /* Subroutine of expand_expr:
        !          3410:    record the non-copied parts (LIST) of an expr (LHS), and return a list
        !          3411:    which specifies the initial values of these parts.  */
        !          3412: 
        !          3413: static tree
        !          3414: init_noncopied_parts (lhs, list)
        !          3415:      tree lhs;
        !          3416:      tree list;
        !          3417: {
        !          3418:   tree tail;
        !          3419:   tree parts = 0;
        !          3420: 
        !          3421:   for (tail = list; tail; tail = TREE_CHAIN (tail))
        !          3422:     if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
        !          3423:       parts = chainon (parts, init_noncopied_parts (lhs, TREE_VALUE (tail)));
        !          3424:     else
        !          3425:       {
        !          3426:        tree part = TREE_VALUE (tail);
        !          3427:        tree part_type = TREE_TYPE (part);
        !          3428:        tree to_be_initialized = build (COMPONENT_REF, part_type, lhs, part);
        !          3429:        parts = tree_cons (TREE_PURPOSE (tail), to_be_initialized, parts);
        !          3430:       }
        !          3431:   return parts;
        !          3432: }
        !          3433: 
        !          3434: /* Subroutine of expand_expr: return nonzero iff there is no way that
        !          3435:    EXP can reference X, which is being modified.  */
        !          3436: 
        !          3437: static int
        !          3438: safe_from_p (x, exp)
        !          3439:      rtx x;
        !          3440:      tree exp;
        !          3441: {
        !          3442:   rtx exp_rtl = 0;
        !          3443:   int i, nops;
        !          3444: 
        !          3445:   if (x == 0)
        !          3446:     return 1;
        !          3447: 
        !          3448:   /* If this is a subreg of a hard register, declare it unsafe, otherwise,
        !          3449:      find the underlying pseudo.  */
        !          3450:   if (GET_CODE (x) == SUBREG)
        !          3451:     {
        !          3452:       x = SUBREG_REG (x);
        !          3453:       if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
        !          3454:        return 0;
        !          3455:     }
        !          3456: 
        !          3457:   /* If X is a location in the outgoing argument area, it is always safe.  */
        !          3458:   if (GET_CODE (x) == MEM
        !          3459:       && (XEXP (x, 0) == virtual_outgoing_args_rtx
        !          3460:          || (GET_CODE (XEXP (x, 0)) == PLUS
        !          3461:              && XEXP (XEXP (x, 0), 0) == virtual_outgoing_args_rtx)))
        !          3462:     return 1;
        !          3463: 
        !          3464:   switch (TREE_CODE_CLASS (TREE_CODE (exp)))
        !          3465:     {
        !          3466:     case 'd':
        !          3467:       exp_rtl = DECL_RTL (exp);
        !          3468:       break;
        !          3469: 
        !          3470:     case 'c':
        !          3471:       return 1;
        !          3472: 
        !          3473:     case 'x':
        !          3474:       if (TREE_CODE (exp) == TREE_LIST)
        !          3475:        return ((TREE_VALUE (exp) == 0
        !          3476:                 || safe_from_p (x, TREE_VALUE (exp)))
        !          3477:                && (TREE_CHAIN (exp) == 0
        !          3478:                    || safe_from_p (x, TREE_CHAIN (exp))));
        !          3479:       else
        !          3480:        return 0;
        !          3481: 
        !          3482:     case '1':
        !          3483:       return safe_from_p (x, TREE_OPERAND (exp, 0));
        !          3484: 
        !          3485:     case '2':
        !          3486:     case '<':
        !          3487:       return (safe_from_p (x, TREE_OPERAND (exp, 0))
        !          3488:              && safe_from_p (x, TREE_OPERAND (exp, 1)));
        !          3489: 
        !          3490:     case 'e':
        !          3491:     case 'r':
        !          3492:       /* Now do code-specific tests.  EXP_RTL is set to any rtx we find in
        !          3493:         the expression.  If it is set, we conflict iff we are that rtx or
        !          3494:         both are in memory.  Otherwise, we check all operands of the
        !          3495:         expression recursively.  */
        !          3496: 
        !          3497:       switch (TREE_CODE (exp))
        !          3498:        {
        !          3499:        case ADDR_EXPR:
        !          3500:          return (staticp (TREE_OPERAND (exp, 0))
        !          3501:                  || safe_from_p (x, TREE_OPERAND (exp, 0)));
        !          3502: 
        !          3503:        case INDIRECT_REF:
        !          3504:          if (GET_CODE (x) == MEM)
        !          3505:            return 0;
        !          3506:          break;
        !          3507: 
        !          3508:        case CALL_EXPR:
        !          3509:          exp_rtl = CALL_EXPR_RTL (exp);
        !          3510:          if (exp_rtl == 0)
        !          3511:            {
        !          3512:              /* Assume that the call will clobber all hard registers and
        !          3513:                 all of memory.  */
        !          3514:              if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
        !          3515:                  || GET_CODE (x) == MEM)
        !          3516:                return 0;
        !          3517:            }
        !          3518: 
        !          3519:          break;
        !          3520: 
        !          3521:        case RTL_EXPR:
        !          3522:          exp_rtl = RTL_EXPR_RTL (exp);
        !          3523:          if (exp_rtl == 0)
        !          3524:            /* We don't know what this can modify.  */
        !          3525:            return 0;
        !          3526: 
        !          3527:          break;
        !          3528: 
        !          3529:        case WITH_CLEANUP_EXPR:
        !          3530:          exp_rtl = RTL_EXPR_RTL (exp);
        !          3531:          break;
        !          3532: 
        !          3533:        case SAVE_EXPR:
        !          3534:          exp_rtl = SAVE_EXPR_RTL (exp);
        !          3535:          break;
        !          3536: 
        !          3537:        case BIND_EXPR:
        !          3538:          /* The only operand we look at is operand 1.  The rest aren't
        !          3539:             part of the expression.  */
        !          3540:          return safe_from_p (x, TREE_OPERAND (exp, 1));
        !          3541: 
        !          3542:        case METHOD_CALL_EXPR:
        !          3543:          /* This takes a rtx argument, but shouldn't appear here. */
        !          3544:          abort ();
        !          3545:        }
        !          3546: 
        !          3547:       /* If we have an rtx, we do not need to scan our operands.  */
        !          3548:       if (exp_rtl)
        !          3549:        break;
        !          3550: 
        !          3551:       nops = tree_code_length[(int) TREE_CODE (exp)];
        !          3552:       for (i = 0; i < nops; i++)
        !          3553:        if (TREE_OPERAND (exp, i) != 0
        !          3554:            && ! safe_from_p (x, TREE_OPERAND (exp, i)))
        !          3555:          return 0;
        !          3556:     }
        !          3557: 
        !          3558:   /* If we have an rtl, find any enclosed object.  Then see if we conflict
        !          3559:      with it.  */
        !          3560:   if (exp_rtl)
        !          3561:     {
        !          3562:       if (GET_CODE (exp_rtl) == SUBREG)
        !          3563:        {
        !          3564:          exp_rtl = SUBREG_REG (exp_rtl);
        !          3565:          if (GET_CODE (exp_rtl) == REG
        !          3566:              && REGNO (exp_rtl) < FIRST_PSEUDO_REGISTER)
        !          3567:            return 0;
        !          3568:        }
        !          3569: 
        !          3570:       /* If the rtl is X, then it is not safe.  Otherwise, it is unless both
        !          3571:         are memory and EXP is not readonly.  */
        !          3572:       return ! (rtx_equal_p (x, exp_rtl)
        !          3573:                || (GET_CODE (x) == MEM && GET_CODE (exp_rtl) == MEM
        !          3574:                    && ! TREE_READONLY (exp)));
        !          3575:     }
        !          3576: 
        !          3577:   /* If we reach here, it is safe.  */
        !          3578:   return 1;
        !          3579: }
        !          3580: 
        !          3581: /* Subroutine of expand_expr: return nonzero iff EXP is an
        !          3582:    expression whose type is statically determinable.  */
        !          3583: 
        !          3584: static int
        !          3585: fixed_type_p (exp)
        !          3586:      tree exp;
        !          3587: {
        !          3588:   if (TREE_CODE (exp) == PARM_DECL
        !          3589:       || TREE_CODE (exp) == VAR_DECL
        !          3590:       || TREE_CODE (exp) == CALL_EXPR || TREE_CODE (exp) == TARGET_EXPR
        !          3591:       || TREE_CODE (exp) == COMPONENT_REF
        !          3592:       || TREE_CODE (exp) == ARRAY_REF)
        !          3593:     return 1;
        !          3594:   return 0;
        !          3595: }
        !          3596: 
        !          3597: /* expand_expr: generate code for computing expression EXP.
        !          3598:    An rtx for the computed value is returned.  The value is never null.
        !          3599:    In the case of a void EXP, const0_rtx is returned.
        !          3600: 
        !          3601:    The value may be stored in TARGET if TARGET is nonzero.
        !          3602:    TARGET is just a suggestion; callers must assume that
        !          3603:    the rtx returned may not be the same as TARGET.
        !          3604: 
        !          3605:    If TARGET is CONST0_RTX, it means that the value will be ignored.
        !          3606: 
        !          3607:    If TMODE is not VOIDmode, it suggests generating the
        !          3608:    result in mode TMODE.  But this is done only when convenient.
        !          3609:    Otherwise, TMODE is ignored and the value generated in its natural mode.
        !          3610:    TMODE is just a suggestion; callers must assume that
        !          3611:    the rtx returned may not have mode TMODE.
        !          3612: 
        !          3613:    EXPAND_CONST_ADDRESS says that it is okay to return a MEM
        !          3614:    with a constant address even if that address is not normally legitimate.
        !          3615:    EXPAND_INITIALIZER and EXPAND_SUM also have this effect.
        !          3616: 
        !          3617:    If MODIFIER is EXPAND_SUM then when EXP is an addition
        !          3618:    we can return an rtx of the form (MULT (REG ...) (CONST_INT ...))
        !          3619:    or a nest of (PLUS ...) and (MINUS ...) where the terms are
        !          3620:    products as above, or REG or MEM, or constant.
        !          3621:    Ordinarily in such cases we would output mul or add instructions
        !          3622:    and then return a pseudo reg containing the sum.
        !          3623: 
        !          3624:    EXPAND_INITIALIZER is much like EXPAND_SUM except that
        !          3625:    it also marks a label as absolutely required (it can't be dead).
        !          3626:    It also makes a ZERO_EXTEND or SIGN_EXTEND instead of emitting extend insns.
        !          3627:    This is used for outputting expressions used in initializers.  */
        !          3628: 
        !          3629: rtx
        !          3630: expand_expr (exp, target, tmode, modifier)
        !          3631:      register tree exp;
        !          3632:      rtx target;
        !          3633:      enum machine_mode tmode;
        !          3634:      enum expand_modifier modifier;
        !          3635: {
        !          3636:   /* Chain of pending expressions for PLACEHOLDER_EXPR to replace.
        !          3637:      This is static so it will be accessible to our recursive callees.  */
        !          3638:   static tree placeholder_list = 0;
        !          3639:   register rtx op0, op1, temp;
        !          3640:   tree type = TREE_TYPE (exp);
        !          3641:   int unsignedp = TREE_UNSIGNED (type);
        !          3642:   register enum machine_mode mode = TYPE_MODE (type);
        !          3643:   register enum tree_code code = TREE_CODE (exp);
        !          3644:   optab this_optab;
        !          3645:   /* Use subtarget as the target for operand 0 of a binary operation.  */
        !          3646:   rtx subtarget = (target != 0 && GET_CODE (target) == REG ? target : 0);
        !          3647:   rtx original_target = target;
        !          3648:   /* Maybe defer this until sure not doing bytecode?  */
        !          3649:   int ignore = (target == const0_rtx
        !          3650:                || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
        !          3651:                     || code == CONVERT_EXPR || code == REFERENCE_EXPR
        !          3652:                     || code == COND_EXPR)
        !          3653:                    && TREE_CODE (type) == VOID_TYPE));
        !          3654:   tree context;
        !          3655: 
        !          3656: 
        !          3657:   if (output_bytecode)
        !          3658:     {
        !          3659:       bc_expand_expr (exp);
        !          3660:       return NULL;
        !          3661:     }
        !          3662: 
        !          3663:   /* Don't use hard regs as subtargets, because the combiner
        !          3664:      can only handle pseudo regs.  */
        !          3665:   if (subtarget && REGNO (subtarget) < FIRST_PSEUDO_REGISTER)
        !          3666:     subtarget = 0;
        !          3667:   /* Avoid subtargets inside loops,
        !          3668:      since they hide some invariant expressions.  */
        !          3669:   if (preserve_subexpressions_p ())
        !          3670:     subtarget = 0;
        !          3671: 
        !          3672:   /* If we are going to ignore this result, we need only do something
        !          3673:      if there is a side-effect somewhere in the expression.  If there
        !          3674:      is, short-circuit the most common cases here.  Note that we must
        !          3675:      not call expand_expr with anything but const0_rtx in case this
        !          3676:      is an initial expansion of a size that contains a PLACEHOLDER_EXPR.  */
        !          3677: 
        !          3678:   if (ignore)
        !          3679:     {
        !          3680:       if (! TREE_SIDE_EFFECTS (exp))
        !          3681:        return const0_rtx;
        !          3682: 
        !          3683:       /* Ensure we reference a volatile object even if value is ignored.  */
        !          3684:       if (TREE_THIS_VOLATILE (exp)
        !          3685:          && TREE_CODE (exp) != FUNCTION_DECL
        !          3686:          && mode != VOIDmode && mode != BLKmode)
        !          3687:        {
        !          3688:          temp = expand_expr (exp, NULL_RTX, VOIDmode, modifier);
        !          3689:          if (GET_CODE (temp) == MEM)
        !          3690:            temp = copy_to_reg (temp);
        !          3691:          return const0_rtx;
        !          3692:        }
        !          3693: 
        !          3694:       if (TREE_CODE_CLASS (code) == '1')
        !          3695:        return expand_expr (TREE_OPERAND (exp, 0), const0_rtx,
        !          3696:                            VOIDmode, modifier);
        !          3697:       else if (TREE_CODE_CLASS (code) == '2'
        !          3698:               || TREE_CODE_CLASS (code) == '<')
        !          3699:        {
        !          3700:          expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, modifier);
        !          3701:          expand_expr (TREE_OPERAND (exp, 1), const0_rtx, VOIDmode, modifier);
        !          3702:          return const0_rtx;
        !          3703:        }
        !          3704:       else if ((code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
        !          3705:               && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1)))
        !          3706:        /* If the second operand has no side effects, just evaluate
        !          3707:           the first. */
        !          3708:        return expand_expr (TREE_OPERAND (exp, 0), const0_rtx,
        !          3709:                            VOIDmode, modifier);
        !          3710: 
        !          3711:       target = 0;
        !          3712:     }
        !          3713: 
        !          3714:   /* If will do cse, generate all results into pseudo registers
        !          3715:      since 1) that allows cse to find more things
        !          3716:      and 2) otherwise cse could produce an insn the machine
        !          3717:      cannot support.  */
        !          3718: 
        !          3719:   if (! cse_not_expected && mode != BLKmode && target
        !          3720:       && (GET_CODE (target) != REG || REGNO (target) < FIRST_PSEUDO_REGISTER))
        !          3721:     target = subtarget;
        !          3722: 
        !          3723:   switch (code)
        !          3724:     {
        !          3725:     case LABEL_DECL:
        !          3726:       {
        !          3727:        tree function = decl_function_context (exp);
        !          3728:        /* Handle using a label in a containing function.  */
        !          3729:        if (function != current_function_decl && function != 0)
        !          3730:          {
        !          3731:            struct function *p = find_function_data (function);
        !          3732:            /* Allocate in the memory associated with the function
        !          3733:               that the label is in.  */
        !          3734:            push_obstacks (p->function_obstack,
        !          3735:                           p->function_maybepermanent_obstack);
        !          3736: 
        !          3737:            p->forced_labels = gen_rtx (EXPR_LIST, VOIDmode,
        !          3738:                                        label_rtx (exp), p->forced_labels);
        !          3739:            pop_obstacks ();
        !          3740:          }
        !          3741:        else if (modifier == EXPAND_INITIALIZER)
        !          3742:          forced_labels = gen_rtx (EXPR_LIST, VOIDmode,
        !          3743:                                   label_rtx (exp), forced_labels);
        !          3744:        temp = gen_rtx (MEM, FUNCTION_MODE,
        !          3745:                        gen_rtx (LABEL_REF, Pmode, label_rtx (exp)));
        !          3746:        if (function != current_function_decl && function != 0)
        !          3747:          LABEL_REF_NONLOCAL_P (XEXP (temp, 0)) = 1;
        !          3748:        return temp;
        !          3749:       }
        !          3750: 
        !          3751:     case PARM_DECL:
        !          3752:       if (DECL_RTL (exp) == 0)
        !          3753:        {
        !          3754:          error_with_decl (exp, "prior parameter's size depends on `%s'");
        !          3755:          return CONST0_RTX (mode);
        !          3756:        }
        !          3757: 
        !          3758:     case VAR_DECL:
        !          3759:       /* If a static var's type was incomplete when the decl was written,
        !          3760:         but the type is complete now, lay out the decl now.  */
        !          3761:       if (DECL_SIZE (exp) == 0 && TYPE_SIZE (TREE_TYPE (exp)) != 0
        !          3762:          && (TREE_STATIC (exp) || DECL_EXTERNAL (exp)))
        !          3763:        {
        !          3764:          push_obstacks_nochange ();
        !          3765:          end_temporary_allocation ();
        !          3766:          layout_decl (exp, 0);
        !          3767:          PUT_MODE (DECL_RTL (exp), DECL_MODE (exp));
        !          3768:          pop_obstacks ();
        !          3769:        }
        !          3770:     case FUNCTION_DECL:
        !          3771:     case RESULT_DECL:
        !          3772:       if (DECL_RTL (exp) == 0)
        !          3773:        abort ();
        !          3774:       /* Ensure variable marked as used even if it doesn't go through
        !          3775:         a parser.  If it hasn't be used yet, write out an external
        !          3776:         definition.  */
        !          3777:       if (! TREE_USED (exp))
        !          3778:        {
        !          3779:          assemble_external (exp);
        !          3780:          TREE_USED (exp) = 1;
        !          3781:        }
        !          3782: 
        !          3783:       /* Handle variables inherited from containing functions.  */
        !          3784:       context = decl_function_context (exp);
        !          3785: 
        !          3786:       /* We treat inline_function_decl as an alias for the current function
        !          3787:         because that is the inline function whose vars, types, etc.
        !          3788:         are being merged into the current function.
        !          3789:         See expand_inline_function.  */
        !          3790:       if (context != 0 && context != current_function_decl
        !          3791:          && context != inline_function_decl
        !          3792:          /* If var is static, we don't need a static chain to access it.  */
        !          3793:          && ! (GET_CODE (DECL_RTL (exp)) == MEM
        !          3794:                && CONSTANT_P (XEXP (DECL_RTL (exp), 0))))
        !          3795:        {
        !          3796:          rtx addr;
        !          3797: 
        !          3798:          /* Mark as non-local and addressable.  */
        !          3799:          DECL_NONLOCAL (exp) = 1;
        !          3800:          mark_addressable (exp);
        !          3801:          if (GET_CODE (DECL_RTL (exp)) != MEM)
        !          3802:            abort ();
        !          3803:          addr = XEXP (DECL_RTL (exp), 0);
        !          3804:          if (GET_CODE (addr) == MEM)
        !          3805:            addr = gen_rtx (MEM, Pmode, fix_lexical_addr (XEXP (addr, 0), exp));
        !          3806:          else
        !          3807:            addr = fix_lexical_addr (addr, exp);
        !          3808:          return change_address (DECL_RTL (exp), mode, addr);
        !          3809:        }
        !          3810: 
        !          3811:       /* This is the case of an array whose size is to be determined
        !          3812:         from its initializer, while the initializer is still being parsed.
        !          3813:         See expand_decl.  */
        !          3814:       if (GET_CODE (DECL_RTL (exp)) == MEM
        !          3815:          && GET_CODE (XEXP (DECL_RTL (exp), 0)) == REG)
        !          3816:        return change_address (DECL_RTL (exp), GET_MODE (DECL_RTL (exp)),
        !          3817:                               XEXP (DECL_RTL (exp), 0));
        !          3818:       if (GET_CODE (DECL_RTL (exp)) == MEM
        !          3819:          && modifier != EXPAND_CONST_ADDRESS
        !          3820:          && modifier != EXPAND_SUM
        !          3821:          && modifier != EXPAND_INITIALIZER)
        !          3822:        {
        !          3823:          /* DECL_RTL probably contains a constant address.
        !          3824:             On RISC machines where a constant address isn't valid,
        !          3825:             make some insns to get that address into a register.  */
        !          3826:          if (!memory_address_p (DECL_MODE (exp), XEXP (DECL_RTL (exp), 0))
        !          3827:              || (flag_force_addr
        !          3828:                  && CONSTANT_ADDRESS_P (XEXP (DECL_RTL (exp), 0))))
        !          3829:            return change_address (DECL_RTL (exp), VOIDmode,
        !          3830:                                   copy_rtx (XEXP (DECL_RTL (exp), 0)));
        !          3831:        }
        !          3832: 
        !          3833:       /* If the mode of DECL_RTL does not match that of the decl, it
        !          3834:         must be a promoted value.  We return a SUBREG of the wanted mode,
        !          3835:         but mark it so that we know that it was already extended.  */
        !          3836: 
        !          3837:       if (GET_CODE (DECL_RTL (exp)) == REG
        !          3838:          && GET_MODE (DECL_RTL (exp)) != mode)
        !          3839:        {
        !          3840:          enum machine_mode decl_mode = DECL_MODE (exp);
        !          3841: 
        !          3842:          /* Get the signedness used for this variable.  Ensure we get the
        !          3843:             same mode we got when the variable was declared.  */
        !          3844: 
        !          3845:          PROMOTE_MODE (decl_mode, unsignedp, type);
        !          3846: 
        !          3847:          if (decl_mode != GET_MODE (DECL_RTL (exp)))
        !          3848:            abort ();
        !          3849: 
        !          3850:          temp = gen_rtx (SUBREG, mode, DECL_RTL (exp), 0);
        !          3851:          SUBREG_PROMOTED_VAR_P (temp) = 1;
        !          3852:          SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
        !          3853:          return temp;
        !          3854:        }
        !          3855: 
        !          3856:       /*
        !          3857:       if (code == VAR_DECL 
        !          3858:          && modifier == EXPAND_NORMAL
        !          3859:          && TREE_SELF_OFFSET (exp))
        !          3860:        {
        !          3861:          rtx op0 = memory_address (mode, XEXP (DECL_RTL (exp), 0));
        !          3862:          rtx op1 = gen_rtx (PLUS, mode, op0, DECL_RTL (exp));
        !          3863:          temp = gen_rtx (MEM, mode, memory_address (mode, op1));
        !          3864:          MEM_IN_STRUCT_P (temp) = 1;
        !          3865:          MEM_VOLATILE_P (temp) = TREE_THIS_VOLATILE (exp);
        !          3866:          return temp;
        !          3867:        }
        !          3868:       else
        !          3869:       */
        !          3870:       return DECL_RTL (exp);
        !          3871: 
        !          3872:     case INTEGER_CST:
        !          3873:       return immed_double_const (TREE_INT_CST_LOW (exp),
        !          3874:                                 TREE_INT_CST_HIGH (exp),
        !          3875:                                 mode);
        !          3876: 
        !          3877:     case CONST_DECL:
        !          3878:       return expand_expr (DECL_INITIAL (exp), target, VOIDmode, 0);
        !          3879: 
        !          3880:     case REAL_CST:
        !          3881:       /* If optimized, generate immediate CONST_DOUBLE
        !          3882:         which will be turned into memory by reload if necessary. 
        !          3883:      
        !          3884:         We used to force a register so that loop.c could see it.  But
        !          3885:         this does not allow gen_* patterns to perform optimizations with
        !          3886:         the constants.  It also produces two insns in cases like "x = 1.0;".
        !          3887:         On most machines, floating-point constants are not permitted in
        !          3888:         many insns, so we'd end up copying it to a register in any case.
        !          3889: 
        !          3890:         Now, we do the copying in expand_binop, if appropriate.  */
        !          3891:       return immed_real_const (exp);
        !          3892: 
        !          3893:     case COMPLEX_CST:
        !          3894:     case STRING_CST:
        !          3895:       if (! TREE_CST_RTL (exp))
        !          3896:        output_constant_def (exp);
        !          3897: 
        !          3898:       /* TREE_CST_RTL probably contains a constant address.
        !          3899:         On RISC machines where a constant address isn't valid,
        !          3900:         make some insns to get that address into a register.  */
        !          3901:       if (GET_CODE (TREE_CST_RTL (exp)) == MEM
        !          3902:          && modifier != EXPAND_CONST_ADDRESS
        !          3903:          && modifier != EXPAND_INITIALIZER
        !          3904:          && modifier != EXPAND_SUM
        !          3905:          && !memory_address_p (mode, XEXP (TREE_CST_RTL (exp), 0)))
        !          3906:        return change_address (TREE_CST_RTL (exp), VOIDmode,
        !          3907:                               copy_rtx (XEXP (TREE_CST_RTL (exp), 0)));
        !          3908:       return TREE_CST_RTL (exp);
        !          3909: 
        !          3910:     case SAVE_EXPR:
        !          3911:       context = decl_function_context (exp);
        !          3912:       /* We treat inline_function_decl as an alias for the current function
        !          3913:         because that is the inline function whose vars, types, etc.
        !          3914:         are being merged into the current function.
        !          3915:         See expand_inline_function.  */
        !          3916:       if (context == current_function_decl || context == inline_function_decl)
        !          3917:        context = 0;
        !          3918: 
        !          3919:       /* If this is non-local, handle it.  */
        !          3920:       if (context)
        !          3921:        {
        !          3922:          temp = SAVE_EXPR_RTL (exp);
        !          3923:          if (temp && GET_CODE (temp) == REG)
        !          3924:            {
        !          3925:              put_var_into_stack (exp);
        !          3926:              temp = SAVE_EXPR_RTL (exp);
        !          3927:            }
        !          3928:          if (temp == 0 || GET_CODE (temp) != MEM)
        !          3929:            abort ();
        !          3930:          return change_address (temp, mode,
        !          3931:                                 fix_lexical_addr (XEXP (temp, 0), exp));
        !          3932:        }
        !          3933:       if (SAVE_EXPR_RTL (exp) == 0)
        !          3934:        {
        !          3935:          if (mode == BLKmode)
        !          3936:            {
        !          3937:              temp
        !          3938:                = assign_stack_temp (mode, int_size_in_bytes (type), 0);
        !          3939:              MEM_IN_STRUCT_P (temp)
        !          3940:                = (TREE_CODE (type) == RECORD_TYPE
        !          3941:                   || TREE_CODE (type) == UNION_TYPE
        !          3942:                   || TREE_CODE (type) == QUAL_UNION_TYPE
        !          3943:                   || TREE_CODE (type) == ARRAY_TYPE);
        !          3944:            }
        !          3945:          else
        !          3946:            {
        !          3947:              enum machine_mode var_mode = mode;
        !          3948: 
        !          3949:              if (TREE_CODE (type) == INTEGER_TYPE
        !          3950:                  || TREE_CODE (type) == ENUMERAL_TYPE
        !          3951:                  || TREE_CODE (type) == BOOLEAN_TYPE
        !          3952:                  || TREE_CODE (type) == CHAR_TYPE
        !          3953:                  || TREE_CODE (type) == REAL_TYPE
        !          3954:                  || TREE_CODE (type) == POINTER_TYPE
        !          3955:                  || TREE_CODE (type) == OFFSET_TYPE)
        !          3956:                {
        !          3957:                  PROMOTE_MODE (var_mode, unsignedp, type);
        !          3958:                }
        !          3959: 
        !          3960:              temp = gen_reg_rtx (var_mode);
        !          3961:            }
        !          3962: 
        !          3963:          SAVE_EXPR_RTL (exp) = temp;
        !          3964:          if (!optimize && GET_CODE (temp) == REG)
        !          3965:            save_expr_regs = gen_rtx (EXPR_LIST, VOIDmode, temp,
        !          3966:                                      save_expr_regs);
        !          3967: 
        !          3968:          /* If the mode of TEMP does not match that of the expression, it
        !          3969:             must be a promoted value.  We pass store_expr a SUBREG of the
        !          3970:             wanted mode but mark it so that we know that it was already
        !          3971:             extended.  Note that `unsignedp' was modified above in
        !          3972:             this case.  */
        !          3973: 
        !          3974:          if (GET_CODE (temp) == REG && GET_MODE (temp) != mode)
        !          3975:            {
        !          3976:              temp = gen_rtx (SUBREG, mode, SAVE_EXPR_RTL (exp), 0);
        !          3977:              SUBREG_PROMOTED_VAR_P (temp) = 1;
        !          3978:              SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
        !          3979:            }
        !          3980: 
        !          3981:          store_expr (TREE_OPERAND (exp, 0), temp, 0);
        !          3982:        }
        !          3983: 
        !          3984:       /* If the mode of SAVE_EXPR_RTL does not match that of the expression, it
        !          3985:         must be a promoted value.  We return a SUBREG of the wanted mode,
        !          3986:         but mark it so that we know that it was already extended. */
        !          3987: 
        !          3988:       if (GET_CODE (SAVE_EXPR_RTL (exp)) == REG
        !          3989:          && GET_MODE (SAVE_EXPR_RTL (exp)) != mode)
        !          3990:        {
        !          3991:          enum machine_mode var_mode = mode;
        !          3992: 
        !          3993:          if (TREE_CODE (type) == INTEGER_TYPE
        !          3994:              || TREE_CODE (type) == ENUMERAL_TYPE
        !          3995:              || TREE_CODE (type) == BOOLEAN_TYPE
        !          3996:              || TREE_CODE (type) == CHAR_TYPE
        !          3997:              || TREE_CODE (type) == REAL_TYPE
        !          3998:              || TREE_CODE (type) == POINTER_TYPE
        !          3999:              || TREE_CODE (type) == OFFSET_TYPE)
        !          4000:            {
        !          4001:              PROMOTE_MODE (var_mode, unsignedp, type);
        !          4002:            }
        !          4003: 
        !          4004:          temp = gen_rtx (SUBREG, mode, SAVE_EXPR_RTL (exp), 0);
        !          4005:          SUBREG_PROMOTED_VAR_P (temp) = 1;
        !          4006:          SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
        !          4007:          return temp;
        !          4008:        }
        !          4009: 
        !          4010:       return SAVE_EXPR_RTL (exp);
        !          4011: 
        !          4012:     case PLACEHOLDER_EXPR:
        !          4013:       /* If there is an object on the head of the placeholder list,
        !          4014:         see if some object in it's references is of type TYPE.  For
        !          4015:         further information, see tree.def.  */
        !          4016:       if (placeholder_list)
        !          4017:        {
        !          4018:          tree object;
        !          4019:          tree old_list = placeholder_list;
        !          4020: 
        !          4021:          for (object = TREE_PURPOSE (placeholder_list);
        !          4022:               TREE_TYPE (object) != type
        !          4023:               && (TREE_CODE_CLASS (TREE_CODE (object)) == 'r'
        !          4024:                   || TREE_CODE_CLASS (TREE_CODE (object)) == '1'
        !          4025:                   || TREE_CODE_CLASS (TREE_CODE (object)) == '2'
        !          4026:                   || TREE_CODE_CLASS (TREE_CODE (object)) == 'e');
        !          4027:               object = TREE_OPERAND (object, 0))
        !          4028:            ;
        !          4029: 
        !          4030:          if (object && TREE_TYPE (object) == type)
        !          4031:            {
        !          4032:              /* Expand this object skipping the list entries before
        !          4033:                 it was found in case it is also a PLACEHOLDER_EXPR.
        !          4034:                 In that case, we want to translate it using subsequent
        !          4035:                 entries.  */
        !          4036:              placeholder_list = TREE_CHAIN (placeholder_list);
        !          4037:              temp = expand_expr (object, original_target, tmode, modifier);
        !          4038:              placeholder_list = old_list;
        !          4039:              return temp;
        !          4040:            }
        !          4041:        }
        !          4042: 
        !          4043:       /* We can't find the object or there was a missing WITH_RECORD_EXPR.  */
        !          4044:       abort ();
        !          4045: 
        !          4046:     case WITH_RECORD_EXPR:
        !          4047:       /* Put the object on the placeholder list, expand our first operand,
        !          4048:         and pop the list.  */
        !          4049:       placeholder_list = tree_cons (TREE_OPERAND (exp, 1), NULL_TREE,
        !          4050:                                    placeholder_list);
        !          4051:       target = expand_expr (TREE_OPERAND (exp, 0), original_target,
        !          4052:                            tmode, modifier);
        !          4053:       placeholder_list = TREE_CHAIN (placeholder_list);
        !          4054:       return target;
        !          4055: 
        !          4056:     case EXIT_EXPR:
        !          4057:       expand_exit_loop_if_false (NULL_PTR,
        !          4058:                                 invert_truthvalue (TREE_OPERAND (exp, 0)));
        !          4059:       return const0_rtx;
        !          4060: 
        !          4061:     case LOOP_EXPR:
        !          4062:       push_temp_slots ();
        !          4063:       expand_start_loop (1);
        !          4064:       expand_expr_stmt (TREE_OPERAND (exp, 0));
        !          4065:       expand_end_loop ();
        !          4066:       pop_temp_slots ();
        !          4067: 
        !          4068:       return const0_rtx;
        !          4069: 
        !          4070:     case BIND_EXPR:
        !          4071:       {
        !          4072:        tree vars = TREE_OPERAND (exp, 0);
        !          4073:        int vars_need_expansion = 0;
        !          4074: 
        !          4075:        /* Need to open a binding contour here because
        !          4076:           if there are any cleanups they most be contained here.  */
        !          4077:        expand_start_bindings (0);
        !          4078: 
        !          4079:        /* Mark the corresponding BLOCK for output in its proper place.  */
        !          4080:        if (TREE_OPERAND (exp, 2) != 0
        !          4081:            && ! TREE_USED (TREE_OPERAND (exp, 2)))
        !          4082:          insert_block (TREE_OPERAND (exp, 2));
        !          4083: 
        !          4084:        /* If VARS have not yet been expanded, expand them now.  */
        !          4085:        while (vars)
        !          4086:          {
        !          4087:            if (DECL_RTL (vars) == 0)
        !          4088:              {
        !          4089:                vars_need_expansion = 1;
        !          4090:                expand_decl (vars);
        !          4091:              }
        !          4092:            expand_decl_init (vars);
        !          4093:            vars = TREE_CHAIN (vars);
        !          4094:          }
        !          4095: 
        !          4096:        temp = expand_expr (TREE_OPERAND (exp, 1), target, tmode, modifier);
        !          4097: 
        !          4098:        expand_end_bindings (TREE_OPERAND (exp, 0), 0, 0);
        !          4099: 
        !          4100:        return temp;
        !          4101:       }
        !          4102: 
        !          4103:     case RTL_EXPR:
        !          4104:       if (RTL_EXPR_SEQUENCE (exp) == const0_rtx)
        !          4105:        abort ();
        !          4106:       emit_insns (RTL_EXPR_SEQUENCE (exp));
        !          4107:       RTL_EXPR_SEQUENCE (exp) = const0_rtx;
        !          4108:       free_temps_for_rtl_expr (exp);
        !          4109:       return RTL_EXPR_RTL (exp);
        !          4110: 
        !          4111:     case CONSTRUCTOR:
        !          4112:       /* If we don't need the result, just ensure we evaluate any
        !          4113:         subexpressions.  */
        !          4114:       if (ignore)
        !          4115:        {
        !          4116:          tree elt;
        !          4117:          for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
        !          4118:            expand_expr (TREE_VALUE (elt), const0_rtx, VOIDmode, 0);
        !          4119:          return const0_rtx;
        !          4120:        }
        !          4121:       /* All elts simple constants => refer to a constant in memory.  But
        !          4122:         if this is a non-BLKmode mode, let it store a field at a time
        !          4123:         since that should make a CONST_INT or CONST_DOUBLE when we
        !          4124:         fold.  If we are making an initializer and all operands are
        !          4125:         constant, put it in memory as well.  */
        !          4126:       else if ((TREE_STATIC (exp)
        !          4127:                && (mode == BLKmode || TREE_ADDRESSABLE (exp)))
        !          4128:               || (modifier == EXPAND_INITIALIZER && TREE_CONSTANT (exp)))
        !          4129:        {
        !          4130:          rtx constructor = output_constant_def (exp);
        !          4131:          if (modifier != EXPAND_CONST_ADDRESS
        !          4132:              && modifier != EXPAND_INITIALIZER
        !          4133:              && modifier != EXPAND_SUM
        !          4134:              && !memory_address_p (GET_MODE (constructor),
        !          4135:                                    XEXP (constructor, 0)))
        !          4136:            constructor = change_address (constructor, VOIDmode,
        !          4137:                                          XEXP (constructor, 0));
        !          4138:          return constructor;
        !          4139:        }
        !          4140: 
        !          4141:       else
        !          4142:        {
        !          4143:          if (target == 0 || ! safe_from_p (target, exp))
        !          4144:            {
        !          4145:              if (mode != BLKmode && ! TREE_ADDRESSABLE (exp))
        !          4146:                target = gen_reg_rtx (mode);
        !          4147:              else
        !          4148:                {
        !          4149:                  enum tree_code c = TREE_CODE (type);
        !          4150:                  target
        !          4151:                    = assign_stack_temp (mode, int_size_in_bytes (type), 0);
        !          4152:                  if (c == RECORD_TYPE || c == UNION_TYPE
        !          4153:                      || c == QUAL_UNION_TYPE || c == ARRAY_TYPE)
        !          4154:                    MEM_IN_STRUCT_P (target) = 1;
        !          4155:                }
        !          4156:            }
        !          4157:          store_constructor (exp, target);
        !          4158:          return target;
        !          4159:        }
        !          4160: 
        !          4161:     case INDIRECT_REF:
        !          4162:       {
        !          4163:        tree exp1 = TREE_OPERAND (exp, 0);
        !          4164:        tree exp2;
        !          4165: 
        !          4166:        /* A SAVE_EXPR as the address in an INDIRECT_EXPR is generated
        !          4167:           for  *PTR += ANYTHING  where PTR is put inside the SAVE_EXPR.
        !          4168:           This code has the same general effect as simply doing
        !          4169:           expand_expr on the save expr, except that the expression PTR
        !          4170:           is computed for use as a memory address.  This means different
        !          4171:           code, suitable for indexing, may be generated.  */
        !          4172:        if (TREE_CODE (exp1) == SAVE_EXPR
        !          4173:            && SAVE_EXPR_RTL (exp1) == 0
        !          4174:            && TREE_CODE (exp2 = TREE_OPERAND (exp1, 0)) != ERROR_MARK
        !          4175:            && TYPE_MODE (TREE_TYPE (exp1)) == Pmode
        !          4176:            && TYPE_MODE (TREE_TYPE (exp2)) == Pmode)
        !          4177:          {
        !          4178:            temp = expand_expr (TREE_OPERAND (exp1, 0), NULL_RTX,
        !          4179:                                VOIDmode, EXPAND_SUM);
        !          4180:            op0 = memory_address (mode, temp);
        !          4181:            op0 = copy_all_regs (op0);
        !          4182:            SAVE_EXPR_RTL (exp1) = op0;
        !          4183:          }
        !          4184:        else
        !          4185:          {
        !          4186:            op0 = expand_expr (exp1, NULL_RTX, VOIDmode, EXPAND_SUM);
        !          4187:            op0 = memory_address (mode, op0);
        !          4188:          }
        !          4189: 
        !          4190:        temp = gen_rtx (MEM, mode, op0);
        !          4191:        /* If address was computed by addition,
        !          4192:           mark this as an element of an aggregate.  */
        !          4193:        if (TREE_CODE (TREE_OPERAND (exp, 0)) == PLUS_EXPR
        !          4194:            || (TREE_CODE (TREE_OPERAND (exp, 0)) == SAVE_EXPR
        !          4195:                && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) == PLUS_EXPR)
        !          4196:            || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
        !          4197:            || TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
        !          4198:            || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE
        !          4199:            || TREE_CODE (TREE_TYPE (exp)) == QUAL_UNION_TYPE
        !          4200:            || (TREE_CODE (exp1) == ADDR_EXPR
        !          4201:                && (exp2 = TREE_OPERAND (exp1, 0))
        !          4202:                && (TREE_CODE (TREE_TYPE (exp2)) == ARRAY_TYPE
        !          4203:                    || TREE_CODE (TREE_TYPE (exp2)) == RECORD_TYPE
        !          4204:                    || TREE_CODE (TREE_TYPE (exp2)) == UNION_TYPE
        !          4205:                    || TREE_CODE (TREE_TYPE (exp2)) == QUAL_UNION_TYPE)))
        !          4206:          MEM_IN_STRUCT_P (temp) = 1;
        !          4207:        MEM_VOLATILE_P (temp) = TREE_THIS_VOLATILE (exp) | flag_volatile;
        !          4208: #if 0 /* It is incorrect to set RTX_UNCHANGING_P here, because the fact that
        !          4209:         a location is accessed through a pointer to const does not mean
        !          4210:         that the value there can never change.  */
        !          4211:        RTX_UNCHANGING_P (temp) = TREE_READONLY (exp);
        !          4212: #endif
        !          4213:        return temp;
        !          4214:       }
        !          4215: 
        !          4216:     case ARRAY_REF:
        !          4217:       if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) != ARRAY_TYPE)
        !          4218:        abort ();
        !          4219: 
        !          4220:       {
        !          4221:        tree array = TREE_OPERAND (exp, 0);
        !          4222:        tree domain = TYPE_DOMAIN (TREE_TYPE (array));
        !          4223:        tree low_bound = domain ? TYPE_MIN_VALUE (domain) : integer_zero_node;
        !          4224:        tree index = TREE_OPERAND (exp, 1);
        !          4225:        tree index_type = TREE_TYPE (index);
        !          4226:        int i;
        !          4227: 
        !          4228:        if (TREE_CODE (low_bound) != INTEGER_CST
        !          4229:            && contains_placeholder_p (low_bound))
        !          4230:          low_bound = build (WITH_RECORD_EXPR, sizetype, low_bound, exp);
        !          4231: 
        !          4232:        /* Optimize the special-case of a zero lower bound.
        !          4233: 
        !          4234:           We convert the low_bound to sizetype to avoid some problems
        !          4235:           with constant folding.  (E.g. suppose the lower bound is 1,
        !          4236:           and its mode is QI.  Without the conversion,  (ARRAY
        !          4237:           +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
        !          4238:           +INDEX), which becomes (ARRAY+255+INDEX).  Oops!)
        !          4239: 
        !          4240:           But sizetype isn't quite right either (especially if
        !          4241:           the lowbound is negative).  FIXME */
        !          4242: 
        !          4243:        if (! integer_zerop (low_bound))
        !          4244:          index = fold (build (MINUS_EXPR, index_type, index,
        !          4245:                               convert (sizetype, low_bound)));
        !          4246: 
        !          4247:        if (TREE_CODE (index) != INTEGER_CST
        !          4248:            || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
        !          4249:          {
        !          4250:            /* Nonconstant array index or nonconstant element size.
        !          4251:               Generate the tree for *(&array+index) and expand that,
        !          4252:               except do it in a language-independent way
        !          4253:               and don't complain about non-lvalue arrays.
        !          4254:               `mark_addressable' should already have been called
        !          4255:               for any array for which this case will be reached.  */
        !          4256: 
        !          4257:            /* Don't forget the const or volatile flag from the array
        !          4258:               element. */
        !          4259:            tree variant_type = build_type_variant (type,
        !          4260:                                                    TREE_READONLY (exp),
        !          4261:                                                    TREE_THIS_VOLATILE (exp));
        !          4262:            tree array_adr = build1 (ADDR_EXPR,
        !          4263:                                     build_pointer_type (variant_type), array);
        !          4264:            tree elt;
        !          4265:            tree size = size_in_bytes (type);
        !          4266: 
        !          4267:            /* Convert the integer argument to a type the same size as a
        !          4268:               pointer so the multiply won't overflow spuriously.  */
        !          4269:            if (TYPE_PRECISION (index_type) != POINTER_SIZE)
        !          4270:              index = convert (type_for_size (POINTER_SIZE, 0), index);
        !          4271: 
        !          4272:            if (TREE_CODE (size) != INTEGER_CST
        !          4273:                && contains_placeholder_p (size))
        !          4274:              size = build (WITH_RECORD_EXPR, sizetype, size, exp);
        !          4275: 
        !          4276:            /* Don't think the address has side effects
        !          4277:               just because the array does.
        !          4278:               (In some cases the address might have side effects,
        !          4279:               and we fail to record that fact here.  However, it should not
        !          4280:               matter, since expand_expr should not care.)  */
        !          4281:            TREE_SIDE_EFFECTS (array_adr) = 0;
        !          4282: 
        !          4283:            elt = build1 (INDIRECT_REF, type,
        !          4284:                          fold (build (PLUS_EXPR,
        !          4285:                                       TYPE_POINTER_TO (variant_type),
        !          4286:                                       array_adr,
        !          4287:                                       fold (build (MULT_EXPR,
        !          4288:                                                    TYPE_POINTER_TO (variant_type),
        !          4289:                                                    index, size)))));
        !          4290: 
        !          4291:            /* Volatility, etc., of new expression is same as old
        !          4292:               expression.  */
        !          4293:            TREE_SIDE_EFFECTS (elt) = TREE_SIDE_EFFECTS (exp);
        !          4294:            TREE_THIS_VOLATILE (elt) = TREE_THIS_VOLATILE (exp);
        !          4295:            TREE_READONLY (elt) = TREE_READONLY (exp);
        !          4296: 
        !          4297:            return expand_expr (elt, target, tmode, modifier);
        !          4298:          }
        !          4299: 
        !          4300:        /* Fold an expression like: "foo"[2].
        !          4301:           This is not done in fold so it won't happen inside &.  */
        !          4302: 
        !          4303:        if (TREE_CODE (array) == STRING_CST
        !          4304:            && TREE_CODE (index) == INTEGER_CST
        !          4305:            && !TREE_INT_CST_HIGH (index)
        !          4306:            && (i = TREE_INT_CST_LOW (index)) < TREE_STRING_LENGTH (array))
        !          4307:          {
        !          4308:            if (TREE_TYPE (TREE_TYPE (array)) == integer_type_node)
        !          4309:              {
        !          4310:                exp = build_int_2 (((int *)TREE_STRING_POINTER (array))[i], 0);
        !          4311:                TREE_TYPE (exp) = integer_type_node;
        !          4312:                return expand_expr (exp, target, tmode, modifier);
        !          4313:              }
        !          4314:            if (TREE_TYPE (TREE_TYPE (array)) == char_type_node)
        !          4315:              {
        !          4316:                exp = build_int_2 (TREE_STRING_POINTER (array)[i], 0);
        !          4317:                TREE_TYPE (exp) = integer_type_node;
        !          4318:                return expand_expr (convert (TREE_TYPE (TREE_TYPE (array)),
        !          4319:                                             exp),
        !          4320:                                    target, tmode, modifier);
        !          4321:              }
        !          4322:          }
        !          4323: 
        !          4324:        /* If this is a constant index into a constant array,
        !          4325:           just get the value from the array.  Handle both the cases when
        !          4326:           we have an explicit constructor and when our operand is a variable
        !          4327:           that was declared const.  */
        !          4328: 
        !          4329:        if (TREE_CODE (array) == CONSTRUCTOR && ! TREE_SIDE_EFFECTS (array))
        !          4330:          {
        !          4331:            if (TREE_CODE (index) == INTEGER_CST
        !          4332:                && TREE_INT_CST_HIGH (index) == 0)
        !          4333:              {
        !          4334:                tree elem = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0));
        !          4335: 
        !          4336:                i = TREE_INT_CST_LOW (index);
        !          4337:                while (elem && i--)
        !          4338:                  elem = TREE_CHAIN (elem);
        !          4339:                if (elem)
        !          4340:                  return expand_expr (fold (TREE_VALUE (elem)), target,
        !          4341:                                      tmode, modifier);
        !          4342:              }
        !          4343:          }
        !          4344:          
        !          4345:        else if (optimize >= 1
        !          4346:                 && TREE_READONLY (array) && ! TREE_SIDE_EFFECTS (array)
        !          4347:                 && TREE_CODE (array) == VAR_DECL && DECL_INITIAL (array)
        !          4348:                 && TREE_CODE (DECL_INITIAL (array)) != ERROR_MARK)
        !          4349:          {
        !          4350:            if (TREE_CODE (index) == INTEGER_CST
        !          4351:                && TREE_INT_CST_HIGH (index) == 0)
        !          4352:              {
        !          4353:                tree init = DECL_INITIAL (array);
        !          4354: 
        !          4355:                i = TREE_INT_CST_LOW (index);
        !          4356:                if (TREE_CODE (init) == CONSTRUCTOR)
        !          4357:                  {
        !          4358:                    tree elem = CONSTRUCTOR_ELTS (init);
        !          4359: 
        !          4360:                    while (elem
        !          4361:                           && !tree_int_cst_equal (TREE_PURPOSE (elem), index))
        !          4362:                      elem = TREE_CHAIN (elem);
        !          4363:                    if (elem)
        !          4364:                      return expand_expr (fold (TREE_VALUE (elem)), target,
        !          4365:                                          tmode, modifier);
        !          4366:                  }
        !          4367:                else if (TREE_CODE (init) == STRING_CST
        !          4368:                         && i < TREE_STRING_LENGTH (init))
        !          4369:                  {
        !          4370:                    temp = GEN_INT (TREE_STRING_POINTER (init)[i]);
        !          4371:                    return convert_to_mode (mode, temp, 0);
        !          4372:                  }
        !          4373:              }
        !          4374:          }
        !          4375:       }
        !          4376: 
        !          4377:       /* Treat array-ref with constant index as a component-ref.  */
        !          4378: 
        !          4379:     case COMPONENT_REF:
        !          4380:       /* Treat union-cast as an ordinary cast, i.e. translate
        !          4381:         "((union foo*)X)->elem" into "*(typeof (foo.elem)*)X",
        !          4382:         so that MEM_IN_STRUCT_P will not be set for the resulting rtl. */
        !          4383: 
        !          4384:       if (TREE_CODE (TREE_OPERAND (exp, 0)) == INDIRECT_REF
        !          4385:          && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == UNION_TYPE
        !          4386:          && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) == NOP_EXPR)
        !          4387:        {
        !          4388:          tree addr = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (exp, 0), 0), 0);
        !          4389:          tree casted_type = build_pointer_type (TREE_TYPE (exp));
        !          4390:          tree casted_addr = build1 (NOP_EXPR, casted_type, addr);
        !          4391:          return expand_expr (build1 (INDIRECT_REF, TREE_TYPE (exp), casted_addr),
        !          4392:                              target, tmode, modifier);
        !          4393:        }
        !          4394:       
        !          4395:       /* Treat bit fields and component refs the same */
        !          4396:  
        !          4397:     case BIT_FIELD_REF:
        !          4398:       /* If the operand is a CONSTRUCTOR, we can just extract the
        !          4399:         appropriate field if it is present.  */
        !          4400:       if (code != ARRAY_REF
        !          4401:          && TREE_CODE (TREE_OPERAND (exp, 0)) == CONSTRUCTOR)
        !          4402:        {
        !          4403:          tree elt;
        !          4404: 
        !          4405:          for (elt = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)); elt;
        !          4406:               elt = TREE_CHAIN (elt))
        !          4407:            if (TREE_PURPOSE (elt) == TREE_OPERAND (exp, 1))
        !          4408:              return expand_expr (TREE_VALUE (elt), target, tmode, modifier);
        !          4409:        }
        !          4410: 
        !          4411:       {
        !          4412:        enum machine_mode mode1;
        !          4413:        int bitsize;
        !          4414:        int bitpos;
        !          4415:        tree offset;
        !          4416:        int volatilep = 0;
        !          4417:        tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
        !          4418:                                        &mode1, &unsignedp, &volatilep);
        !          4419:        int alignment;
        !          4420: 
        !          4421:        /* If we got back the original object, something is wrong.  Perhaps
        !          4422:           we are evaluating an expression too early.  In any event, don't
        !          4423:           infinitely recurse.  */
        !          4424:        if (tem == exp)
        !          4425:          abort ();
        !          4426: 
        !          4427:        /* In some cases, we will be offsetting OP0's address by a constant.
        !          4428:           So get it as a sum, if possible.  If we will be using it
        !          4429:           directly in an insn, we validate it.  */
        !          4430:        op0 = expand_expr (tem, NULL_RTX, VOIDmode, EXPAND_SUM);
        !          4431: 
        !          4432:        /* If this is a constant, put it into a register if it is a
        !          4433:           legitimate constant and memory if it isn't.  */
        !          4434:        if (CONSTANT_P (op0))
        !          4435:          {
        !          4436:            enum machine_mode mode = TYPE_MODE (TREE_TYPE (tem));
        !          4437:            if (mode != BLKmode && LEGITIMATE_CONSTANT_P (op0))
        !          4438:              op0 = force_reg (mode, op0);
        !          4439:            else
        !          4440:              op0 = validize_mem (force_const_mem (mode, op0));
        !          4441:          }
        !          4442: 
        !          4443:        alignment = TYPE_ALIGN (TREE_TYPE (tem)) / BITS_PER_UNIT;
        !          4444:        if (offset != 0)
        !          4445:          {
        !          4446:            rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
        !          4447: 
        !          4448:            if (GET_CODE (op0) != MEM)
        !          4449:              abort ();
        !          4450:            op0 = change_address (op0, VOIDmode,
        !          4451:                                  gen_rtx (PLUS, Pmode, XEXP (op0, 0),
        !          4452:                                           force_reg (Pmode, offset_rtx)));
        !          4453:          /* If we have a variable offset, the known alignment
        !          4454:             is only that of the innermost structure containing the field.
        !          4455:             (Actually, we could sometimes do better by using the
        !          4456:             size of an element of the innermost array, but no need.)  */
        !          4457:          if (TREE_CODE (exp) == COMPONENT_REF
        !          4458:              || TREE_CODE (exp) == BIT_FIELD_REF)
        !          4459:            alignment = (TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp, 0)))
        !          4460:                         / BITS_PER_UNIT);
        !          4461:          }
        !          4462: 
        !          4463:        /* Don't forget about volatility even if this is a bitfield.  */
        !          4464:        if (GET_CODE (op0) == MEM && volatilep && ! MEM_VOLATILE_P (op0))
        !          4465:          {
        !          4466:            op0 = copy_rtx (op0);
        !          4467:            MEM_VOLATILE_P (op0) = 1;
        !          4468:          }
        !          4469: 
        !          4470:        /* In cases where an aligned union has an unaligned object
        !          4471:           as a field, we might be extracting a BLKmode value from
        !          4472:           an integer-mode (e.g., SImode) object.  Handle this case
        !          4473:           by doing the extract into an object as wide as the field
        !          4474:           (which we know to be the width of a basic mode), then
        !          4475:           storing into memory, and changing the mode to BLKmode.  */
        !          4476:        if (mode1 == VOIDmode
        !          4477:            || (mode1 != BLKmode && ! direct_load[(int) mode1]
        !          4478:                && modifier != EXPAND_CONST_ADDRESS
        !          4479:                && modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
        !          4480:            || GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
        !          4481:            /* If the field isn't aligned enough to fetch as a memref,
        !          4482:               fetch it as a bit field.  */
        !          4483:            || (STRICT_ALIGNMENT
        !          4484:                && TYPE_ALIGN (TREE_TYPE (tem)) < GET_MODE_ALIGNMENT (mode))
        !          4485:            || (STRICT_ALIGNMENT && bitpos % GET_MODE_ALIGNMENT (mode) != 0))
        !          4486:          {
        !          4487:            enum machine_mode ext_mode = mode;
        !          4488: 
        !          4489:            if (ext_mode == BLKmode)
        !          4490:              ext_mode = mode_for_size (bitsize, MODE_INT, 1);
        !          4491: 
        !          4492:            if (ext_mode == BLKmode)
        !          4493:              abort ();
        !          4494: 
        !          4495:            op0 = extract_bit_field (validize_mem (op0), bitsize, bitpos,
        !          4496:                                     unsignedp, target, ext_mode, ext_mode,
        !          4497:                                     alignment,
        !          4498:                                     int_size_in_bytes (TREE_TYPE (tem)));
        !          4499:            if (mode == BLKmode)
        !          4500:              {
        !          4501:                rtx new = assign_stack_temp (ext_mode,
        !          4502:                                             bitsize / BITS_PER_UNIT, 0);
        !          4503: 
        !          4504:                emit_move_insn (new, op0);
        !          4505:                op0 = copy_rtx (new);
        !          4506:                PUT_MODE (op0, BLKmode);
        !          4507:                MEM_IN_STRUCT_P (op0) = 1;
        !          4508:              }
        !          4509: 
        !          4510:            return op0;
        !          4511:          }
        !          4512: 
        !          4513:        /* Get a reference to just this component.  */
        !          4514:        if (modifier == EXPAND_CONST_ADDRESS
        !          4515:            || modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
        !          4516:          op0 = gen_rtx (MEM, mode1, plus_constant (XEXP (op0, 0),
        !          4517:                                                    (bitpos / BITS_PER_UNIT)));
        !          4518:        else
        !          4519:          op0 = change_address (op0, mode1,
        !          4520:                                plus_constant (XEXP (op0, 0),
        !          4521:                                               (bitpos / BITS_PER_UNIT)));
        !          4522:        MEM_IN_STRUCT_P (op0) = 1;
        !          4523:        MEM_VOLATILE_P (op0) |= volatilep;
        !          4524:        if (mode == mode1 || mode1 == BLKmode || mode1 == tmode)
        !          4525:          target = op0;
        !          4526:        else 
        !          4527:          {
        !          4528:            if (target == 0)
        !          4529:              target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
        !          4530:            convert_move (target, op0, unsignedp);
        !          4531:          }
        !          4532:        /*
        !          4533:        if (modifier == EXPAND_NORMAL 
        !          4534:            && TREE_SELF_OFFSET (TREE_OPERAND (exp, 1)))
        !          4535:          {
        !          4536:            rtx op0 = memory_address (mode, XEXP (target, 0));
        !          4537:            rtx op1 = gen_rtx (PLUS, mode, op0, target);
        !          4538:            temp = gen_rtx (MEM, mode, memory_address (mode, op1));
        !          4539:            MEM_IN_STRUCT_P (temp) = 1;
        !          4540:            MEM_VOLATILE_P (temp) = MEM_VOLATILE_P (target);
        !          4541:            return temp;
        !          4542:          }
        !          4543:        else
        !          4544:        */
        !          4545:          return target;
        !          4546:       }
        !          4547: 
        !          4548:     case OFFSET_REF:
        !          4549:       {
        !          4550:        tree base = build1 (ADDR_EXPR, type, TREE_OPERAND (exp, 0));
        !          4551:        tree addr = build (PLUS_EXPR, type, base, TREE_OPERAND (exp, 1));
        !          4552:        op0 = expand_expr (addr, NULL_RTX, VOIDmode, EXPAND_SUM);
        !          4553:        temp = gen_rtx (MEM, mode, memory_address (mode, op0));
        !          4554:        MEM_IN_STRUCT_P (temp) = 1;
        !          4555:        MEM_VOLATILE_P (temp) = TREE_THIS_VOLATILE (exp);
        !          4556: #if 0 /* It is incorrect to set RTX_UNCHANGING_P here, because the fact that
        !          4557:         a location is accessed through a pointer to const does not mean
        !          4558:         that the value there can never change.  */
        !          4559:        RTX_UNCHANGING_P (temp) = TREE_READONLY (exp);
        !          4560: #endif
        !          4561:        return temp;
        !          4562:       }
        !          4563: 
        !          4564:       /* Intended for a reference to a buffer of a file-object in Pascal.
        !          4565:         But it's not certain that a special tree code will really be
        !          4566:         necessary for these.  INDIRECT_REF might work for them.  */
        !          4567:     case BUFFER_REF:
        !          4568:       abort ();
        !          4569: 
        !          4570:     /* IN_EXPR: Inlined pascal set IN expression.
        !          4571: 
        !          4572:        Algorithm:
        !          4573:          rlo       = set_low - (set_low%bits_per_word);
        !          4574:         the_word  = set [ (index - rlo)/bits_per_word ];
        !          4575:         bit_index = index % bits_per_word;
        !          4576:         bitmask   = 1 << bit_index;
        !          4577:         return !!(the_word & bitmask);  */
        !          4578:     case IN_EXPR:
        !          4579:       preexpand_calls (exp);
        !          4580:       {
        !          4581:        tree set = TREE_OPERAND (exp, 0);
        !          4582:        tree index = TREE_OPERAND (exp, 1);
        !          4583:        tree set_type = TREE_TYPE (set);
        !          4584: 
        !          4585:        tree set_low_bound = TYPE_MIN_VALUE (TYPE_DOMAIN (set_type));
        !          4586:        tree set_high_bound = TYPE_MAX_VALUE (TYPE_DOMAIN (set_type));
        !          4587: 
        !          4588:        rtx index_val;
        !          4589:        rtx lo_r;
        !          4590:        rtx hi_r;
        !          4591:        rtx rlow;
        !          4592:        rtx diff, quo, rem, addr, bit, result;
        !          4593:        rtx setval, setaddr;
        !          4594:        enum machine_mode index_mode = TYPE_MODE (TREE_TYPE (index));
        !          4595: 
        !          4596:        if (target == 0)
        !          4597:          target = gen_reg_rtx (mode);
        !          4598: 
        !          4599:        /* If domain is empty, answer is no.  */
        !          4600:        if (tree_int_cst_lt (set_high_bound, set_low_bound))
        !          4601:          return const0_rtx;
        !          4602: 
        !          4603:        index_val = expand_expr (index, 0, VOIDmode, 0);
        !          4604:        lo_r = expand_expr (set_low_bound, 0, VOIDmode, 0);
        !          4605:        hi_r = expand_expr (set_high_bound, 0, VOIDmode, 0);
        !          4606:        setval = expand_expr (set, 0, VOIDmode, 0);
        !          4607:        setaddr = XEXP (setval, 0); 
        !          4608: 
        !          4609:        /* Compare index against bounds, if they are constant.  */
        !          4610:        if (GET_CODE (index_val) == CONST_INT
        !          4611:            && GET_CODE (lo_r) == CONST_INT
        !          4612:            && INTVAL (index_val) < INTVAL (lo_r))
        !          4613:          return const0_rtx;
        !          4614: 
        !          4615:        if (GET_CODE (index_val) == CONST_INT
        !          4616:            && GET_CODE (hi_r) == CONST_INT
        !          4617:            && INTVAL (hi_r) < INTVAL (index_val))
        !          4618:          return const0_rtx;
        !          4619: 
        !          4620:        /* If we get here, we have to generate the code for both cases
        !          4621:           (in range and out of range).  */
        !          4622: 
        !          4623:        op0 = gen_label_rtx ();
        !          4624:        op1 = gen_label_rtx ();
        !          4625: 
        !          4626:        if (! (GET_CODE (index_val) == CONST_INT
        !          4627:               && GET_CODE (lo_r) == CONST_INT))
        !          4628:          {
        !          4629:            emit_cmp_insn (index_val, lo_r, LT, NULL_RTX,
        !          4630:                           GET_MODE (index_val), 0, 0);
        !          4631:            emit_jump_insn (gen_blt (op1));
        !          4632:          }
        !          4633: 
        !          4634:        if (! (GET_CODE (index_val) == CONST_INT
        !          4635:               && GET_CODE (hi_r) == CONST_INT))
        !          4636:          {
        !          4637:            emit_cmp_insn (index_val, hi_r, GT, NULL_RTX,
        !          4638:                           GET_MODE (index_val), 0, 0);
        !          4639:            emit_jump_insn (gen_bgt (op1));
        !          4640:          }
        !          4641: 
        !          4642:        /* Calculate the element number of bit zero in the first word
        !          4643:           of the set.  */
        !          4644:        if (GET_CODE (lo_r) == CONST_INT)
        !          4645:          rlow = GEN_INT (INTVAL (lo_r)
        !          4646:                          & ~ ((HOST_WIDE_INT) 1 << BITS_PER_UNIT));
        !          4647:        else
        !          4648:          rlow = expand_binop (index_mode, and_optab, lo_r,
        !          4649:                               GEN_INT (~((HOST_WIDE_INT) 1 << BITS_PER_UNIT)),
        !          4650:                               NULL_RTX, 0, OPTAB_LIB_WIDEN);
        !          4651: 
        !          4652:        diff = expand_binop (index_mode, sub_optab,
        !          4653:                             index_val, rlow, NULL_RTX, 0, OPTAB_LIB_WIDEN);
        !          4654: 
        !          4655:        quo = expand_divmod (0, TRUNC_DIV_EXPR, index_mode, diff,
        !          4656:                             GEN_INT (BITS_PER_UNIT), NULL_RTX, 0);
        !          4657:        rem = expand_divmod (1, TRUNC_MOD_EXPR, index_mode, index_val,
        !          4658:                             GEN_INT (BITS_PER_UNIT), NULL_RTX, 0);
        !          4659:        addr = memory_address (byte_mode,
        !          4660:                               expand_binop (index_mode, add_optab,
        !          4661:                                             diff, setaddr, NULL_RTX, 0,
        !          4662:                                             OPTAB_LIB_WIDEN));
        !          4663:        /* Extract the bit we want to examine */
        !          4664:        bit = expand_shift (RSHIFT_EXPR, byte_mode,
        !          4665:                            gen_rtx (MEM, byte_mode, addr),
        !          4666:                            make_tree (TREE_TYPE (index), rem),
        !          4667:                            NULL_RTX, 1);
        !          4668:        result = expand_binop (byte_mode, and_optab, bit, const1_rtx,
        !          4669:                               GET_MODE (target) == byte_mode ? target : 0,
        !          4670:                               1, OPTAB_LIB_WIDEN);
        !          4671: 
        !          4672:        if (result != target)
        !          4673:          convert_move (target, result, 1);
        !          4674: 
        !          4675:        /* Output the code to handle the out-of-range case.  */
        !          4676:        emit_jump (op0);
        !          4677:        emit_label (op1);
        !          4678:        emit_move_insn (target, const0_rtx);
        !          4679:        emit_label (op0);
        !          4680:        return target;
        !          4681:       }
        !          4682: 
        !          4683:     case WITH_CLEANUP_EXPR:
        !          4684:       if (RTL_EXPR_RTL (exp) == 0)
        !          4685:        {
        !          4686:          RTL_EXPR_RTL (exp)
        !          4687:            = expand_expr (TREE_OPERAND (exp, 0),
        !          4688:                           target ? target : const0_rtx,
        !          4689:                           tmode, modifier);
        !          4690:          cleanups_this_call
        !          4691:            = tree_cons (NULL_TREE, TREE_OPERAND (exp, 2), cleanups_this_call);
        !          4692:          /* That's it for this cleanup.  */
        !          4693:          TREE_OPERAND (exp, 2) = 0;
        !          4694:        }
        !          4695:       return RTL_EXPR_RTL (exp);
        !          4696: 
        !          4697:     case CALL_EXPR:
        !          4698:       /* Check for a built-in function.  */
        !          4699:       if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
        !          4700:          && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) == FUNCTION_DECL
        !          4701:          && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
        !          4702:        return expand_builtin (exp, target, subtarget, tmode, ignore);
        !          4703:       /* If this call was expanded already by preexpand_calls,
        !          4704:         just return the result we got.  */
        !          4705:       if (CALL_EXPR_RTL (exp) != 0)
        !          4706:        return CALL_EXPR_RTL (exp);
        !          4707:       return expand_call (exp, target, ignore);
        !          4708: 
        !          4709:     case NON_LVALUE_EXPR:
        !          4710:     case NOP_EXPR:
        !          4711:     case CONVERT_EXPR:
        !          4712:     case REFERENCE_EXPR:
        !          4713:       if (mode == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
        !          4714:        return expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, modifier);
        !          4715:       if (TREE_CODE (type) == UNION_TYPE)
        !          4716:        {
        !          4717:          tree valtype = TREE_TYPE (TREE_OPERAND (exp, 0));
        !          4718:          if (target == 0)
        !          4719:            {
        !          4720:              if (mode == BLKmode)
        !          4721:                {
        !          4722:                  if (TYPE_SIZE (type) == 0
        !          4723:                      || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
        !          4724:                    abort ();
        !          4725:                  target = assign_stack_temp (BLKmode,
        !          4726:                                              (TREE_INT_CST_LOW (TYPE_SIZE (type))
        !          4727:                                               + BITS_PER_UNIT - 1)
        !          4728:                                              / BITS_PER_UNIT, 0);
        !          4729:                }
        !          4730:              else
        !          4731:                target = gen_reg_rtx (mode);
        !          4732:            }
        !          4733:          if (GET_CODE (target) == MEM)
        !          4734:            /* Store data into beginning of memory target.  */
        !          4735:            store_expr (TREE_OPERAND (exp, 0),
        !          4736:                        change_address (target, TYPE_MODE (valtype), 0), 0);
        !          4737: 
        !          4738:          else if (GET_CODE (target) == REG)
        !          4739:            /* Store this field into a union of the proper type.  */
        !          4740:            store_field (target, GET_MODE_BITSIZE (TYPE_MODE (valtype)), 0,
        !          4741:                         TYPE_MODE (valtype), TREE_OPERAND (exp, 0),
        !          4742:                         VOIDmode, 0, 1,
        !          4743:                         int_size_in_bytes (TREE_TYPE (TREE_OPERAND (exp, 0))));
        !          4744:          else
        !          4745:            abort ();
        !          4746: 
        !          4747:          /* Return the entire union.  */
        !          4748:          return target;
        !          4749:        }
        !          4750:       op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, mode, 0);
        !          4751:       if (GET_MODE (op0) == mode)
        !          4752:        return op0;
        !          4753:       /* If arg is a constant integer being extended from a narrower mode,
        !          4754:         we must really truncate to get the extended bits right.  Otherwise
        !          4755:         (unsigned long) (unsigned char) ("\377"[0])
        !          4756:         would come out as ffffffff.  */
        !          4757:       if (GET_MODE (op0) == VOIDmode
        !          4758:          && (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
        !          4759:              < GET_MODE_BITSIZE (mode)))
        !          4760:        {
        !          4761:          /* MODE must be narrower than HOST_BITS_PER_INT.  */
        !          4762:          int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))));
        !          4763: 
        !          4764:          if (width < HOST_BITS_PER_WIDE_INT)
        !          4765:            {
        !          4766:              HOST_WIDE_INT val = (GET_CODE (op0) == CONST_INT ? INTVAL (op0)
        !          4767:                                   : CONST_DOUBLE_LOW (op0));
        !          4768:              if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)))
        !          4769:                  || !(val & ((HOST_WIDE_INT) 1 << (width - 1))))
        !          4770:                val &= ((HOST_WIDE_INT) 1 << width) - 1;
        !          4771:              else
        !          4772:                val |= ~(((HOST_WIDE_INT) 1 << width) - 1);
        !          4773: 
        !          4774:              op0 = GEN_INT (val);
        !          4775:            }
        !          4776:          else
        !          4777:            {
        !          4778:              op0 = (simplify_unary_operation
        !          4779:                     ((TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)))
        !          4780:                       ? ZERO_EXTEND : SIGN_EXTEND),
        !          4781:                      mode, op0,
        !          4782:                      TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))));
        !          4783:              if (op0 == 0)
        !          4784:                abort ();
        !          4785:            }
        !          4786:        }
        !          4787:       if (GET_MODE (op0) == VOIDmode)
        !          4788:        return op0;
        !          4789:       if (modifier == EXPAND_INITIALIZER)
        !          4790:        return gen_rtx (unsignedp ? ZERO_EXTEND : SIGN_EXTEND, mode, op0);
        !          4791:       if (flag_force_mem && GET_CODE (op0) == MEM)
        !          4792:        op0 = copy_to_reg (op0);
        !          4793: 
        !          4794:       if (target == 0)
        !          4795:        return convert_to_mode (mode, op0, TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
        !          4796:       else
        !          4797:        convert_move (target, op0, TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
        !          4798:       return target;
        !          4799: 
        !          4800:     case PLUS_EXPR:
        !          4801:       /* We come here from MINUS_EXPR when the second operand is a constant. */
        !          4802:     plus_expr:
        !          4803:       this_optab = add_optab;
        !          4804: 
        !          4805:       /* If we are adding a constant, an RTL_EXPR that is sp, fp, or ap, and
        !          4806:         something else, make sure we add the register to the constant and
        !          4807:         then to the other thing.  This case can occur during strength
        !          4808:         reduction and doing it this way will produce better code if the
        !          4809:         frame pointer or argument pointer is eliminated.
        !          4810: 
        !          4811:         fold-const.c will ensure that the constant is always in the inner
        !          4812:         PLUS_EXPR, so the only case we need to do anything about is if
        !          4813:         sp, ap, or fp is our second argument, in which case we must swap
        !          4814:         the innermost first argument and our second argument.  */
        !          4815: 
        !          4816:       if (TREE_CODE (TREE_OPERAND (exp, 0)) == PLUS_EXPR
        !          4817:          && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 1)) == INTEGER_CST
        !          4818:          && TREE_CODE (TREE_OPERAND (exp, 1)) == RTL_EXPR
        !          4819:          && (RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == frame_pointer_rtx
        !          4820:              || RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == stack_pointer_rtx
        !          4821:              || RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == arg_pointer_rtx))
        !          4822:        {
        !          4823:          tree t = TREE_OPERAND (exp, 1);
        !          4824: 
        !          4825:          TREE_OPERAND (exp, 1) = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
        !          4826:          TREE_OPERAND (TREE_OPERAND (exp, 0), 0) = t;
        !          4827:        }
        !          4828: 
        !          4829:       /* If the result is to be Pmode and we are adding an integer to
        !          4830:         something, we might be forming a constant.  So try to use
        !          4831:         plus_constant.  If it produces a sum and we can't accept it,
        !          4832:         use force_operand.  This allows P = &ARR[const] to generate
        !          4833:         efficient code on machines where a SYMBOL_REF is not a valid
        !          4834:         address.
        !          4835: 
        !          4836:         If this is an EXPAND_SUM call, always return the sum.  */
        !          4837:       if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER
        !          4838:          || mode == Pmode)
        !          4839:        {
        !          4840:          if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
        !          4841:              && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
        !          4842:              && TREE_CONSTANT (TREE_OPERAND (exp, 1)))
        !          4843:            {
        !          4844:              op1 = expand_expr (TREE_OPERAND (exp, 1), subtarget, VOIDmode,
        !          4845:                                 EXPAND_SUM);
        !          4846:              op1 = plus_constant (op1, TREE_INT_CST_LOW (TREE_OPERAND (exp, 0)));
        !          4847:              if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
        !          4848:                op1 = force_operand (op1, target);
        !          4849:              return op1;
        !          4850:            }
        !          4851: 
        !          4852:          else if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
        !          4853:                   && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT
        !          4854:                   && TREE_CONSTANT (TREE_OPERAND (exp, 0)))
        !          4855:            {
        !          4856:              op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode,
        !          4857:                                 EXPAND_SUM);
        !          4858:              if (! CONSTANT_P (op0))
        !          4859:                {
        !          4860:                  op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
        !          4861:                                     VOIDmode, modifier);
        !          4862:                  /* Don't go to both_summands if modifier
        !          4863:                     says it's not right to return a PLUS.  */
        !          4864:                  if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
        !          4865:                    goto binop2;
        !          4866:                  goto both_summands;
        !          4867:                }
        !          4868:              op0 = plus_constant (op0, TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)));
        !          4869:              if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
        !          4870:                op0 = force_operand (op0, target);
        !          4871:              return op0;
        !          4872:            }
        !          4873:        }
        !          4874: 
        !          4875:       /* No sense saving up arithmetic to be done
        !          4876:         if it's all in the wrong mode to form part of an address.
        !          4877:         And force_operand won't know whether to sign-extend or
        !          4878:         zero-extend.  */
        !          4879:       if ((modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
        !          4880:          || mode != Pmode)
        !          4881:        goto binop;
        !          4882: 
        !          4883:       preexpand_calls (exp);
        !          4884:       if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1)))
        !          4885:        subtarget = 0;
        !          4886: 
        !          4887:       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, modifier);
        !          4888:       op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, modifier);
        !          4889: 
        !          4890:     both_summands:
        !          4891:       /* Make sure any term that's a sum with a constant comes last.  */
        !          4892:       if (GET_CODE (op0) == PLUS
        !          4893:          && CONSTANT_P (XEXP (op0, 1)))
        !          4894:        {
        !          4895:          temp = op0;
        !          4896:          op0 = op1;
        !          4897:          op1 = temp;
        !          4898:        }
        !          4899:       /* If adding to a sum including a constant,
        !          4900:         associate it to put the constant outside.  */
        !          4901:       if (GET_CODE (op1) == PLUS
        !          4902:          && CONSTANT_P (XEXP (op1, 1)))
        !          4903:        {
        !          4904:          rtx constant_term = const0_rtx;
        !          4905: 
        !          4906:          temp = simplify_binary_operation (PLUS, mode, XEXP (op1, 0), op0);
        !          4907:          if (temp != 0)
        !          4908:            op0 = temp;
        !          4909:          /* Ensure that MULT comes first if there is one.  */
        !          4910:          else if (GET_CODE (op0) == MULT)
        !          4911:            op0 = gen_rtx (PLUS, mode, op0, XEXP (op1, 0));
        !          4912:          else
        !          4913:            op0 = gen_rtx (PLUS, mode, XEXP (op1, 0), op0);
        !          4914: 
        !          4915:          /* Let's also eliminate constants from op0 if possible.  */
        !          4916:          op0 = eliminate_constant_term (op0, &constant_term);
        !          4917: 
        !          4918:          /* CONSTANT_TERM and XEXP (op1, 1) are known to be constant, so
        !          4919:             their sum should be a constant.  Form it into OP1, since the 
        !          4920:             result we want will then be OP0 + OP1.  */
        !          4921: 
        !          4922:          temp = simplify_binary_operation (PLUS, mode, constant_term,
        !          4923:                                            XEXP (op1, 1));
        !          4924:          if (temp != 0)
        !          4925:            op1 = temp;
        !          4926:          else
        !          4927:            op1 = gen_rtx (PLUS, mode, constant_term, XEXP (op1, 1));
        !          4928:        }
        !          4929: 
        !          4930:       /* Put a constant term last and put a multiplication first.  */
        !          4931:       if (CONSTANT_P (op0) || GET_CODE (op1) == MULT)
        !          4932:        temp = op1, op1 = op0, op0 = temp;
        !          4933: 
        !          4934:       temp = simplify_binary_operation (PLUS, mode, op0, op1);
        !          4935:       return temp ? temp : gen_rtx (PLUS, mode, op0, op1);
        !          4936: 
        !          4937:     case MINUS_EXPR:
        !          4938:       /* For initializers, we are allowed to return a MINUS of two
        !          4939:         symbolic constants.  Here we handle all cases when both operands
        !          4940:         are constant.  */
        !          4941:       /* Handle difference of two symbolic constants,
        !          4942:         for the sake of an initializer.  */
        !          4943:       if ((modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
        !          4944:          && really_constant_p (TREE_OPERAND (exp, 0))
        !          4945:          && really_constant_p (TREE_OPERAND (exp, 1)))
        !          4946:        {
        !          4947:          rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX,
        !          4948:                                 VOIDmode, modifier);
        !          4949:          rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
        !          4950:                                 VOIDmode, modifier);
        !          4951: 
        !          4952:          /* If one operand is a CONST_INT, put it last.  */
        !          4953:          if (GET_CODE (op0) == CONST_INT)
        !          4954:            temp = op0, op0 = op1, op1 = temp;
        !          4955: 
        !          4956:          /* If the last operand is a CONST_INT, use plus_constant of
        !          4957:             the negated constant.  Else make the MINUS.  */
        !          4958:          if (GET_CODE (op1) == CONST_INT)
        !          4959:            return plus_constant (op0, - INTVAL (op1));
        !          4960:          else
        !          4961:            return gen_rtx (MINUS, mode, op0, op1);
        !          4962:        }
        !          4963:       /* Convert A - const to A + (-const).  */
        !          4964:       if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
        !          4965:        {
        !          4966:          exp = build (PLUS_EXPR, type, TREE_OPERAND (exp, 0),
        !          4967:                       fold (build1 (NEGATE_EXPR, type,
        !          4968:                                     TREE_OPERAND (exp, 1))));
        !          4969:          goto plus_expr;
        !          4970:        }
        !          4971:       this_optab = sub_optab;
        !          4972:       goto binop;
        !          4973: 
        !          4974:     case MULT_EXPR:
        !          4975:       preexpand_calls (exp);
        !          4976:       /* If first operand is constant, swap them.
        !          4977:         Thus the following special case checks need only
        !          4978:         check the second operand.  */
        !          4979:       if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST)
        !          4980:        {
        !          4981:          register tree t1 = TREE_OPERAND (exp, 0);
        !          4982:          TREE_OPERAND (exp, 0) = TREE_OPERAND (exp, 1);
        !          4983:          TREE_OPERAND (exp, 1) = t1;
        !          4984:        }
        !          4985: 
        !          4986:       /* Attempt to return something suitable for generating an
        !          4987:         indexed address, for machines that support that.  */
        !          4988: 
        !          4989:       if (modifier == EXPAND_SUM && mode == Pmode
        !          4990:          && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
        !          4991:          && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
        !          4992:        {
        !          4993:          op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, EXPAND_SUM);
        !          4994: 
        !          4995:          /* Apply distributive law if OP0 is x+c.  */
        !          4996:          if (GET_CODE (op0) == PLUS
        !          4997:              && GET_CODE (XEXP (op0, 1)) == CONST_INT)
        !          4998:            return gen_rtx (PLUS, mode,
        !          4999:                            gen_rtx (MULT, mode, XEXP (op0, 0),
        !          5000:                                     GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))),
        !          5001:                            GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))
        !          5002:                                     * INTVAL (XEXP (op0, 1))));
        !          5003: 
        !          5004:          if (GET_CODE (op0) != REG)
        !          5005:            op0 = force_operand (op0, NULL_RTX);
        !          5006:          if (GET_CODE (op0) != REG)
        !          5007:            op0 = copy_to_mode_reg (mode, op0);
        !          5008: 
        !          5009:          return gen_rtx (MULT, mode, op0,
        !          5010:                          GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))));
        !          5011:        }
        !          5012: 
        !          5013:       if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1)))
        !          5014:        subtarget = 0;
        !          5015: 
        !          5016:       /* Check for multiplying things that have been extended
        !          5017:         from a narrower type.  If this machine supports multiplying
        !          5018:         in that narrower type with a result in the desired type,
        !          5019:         do it that way, and avoid the explicit type-conversion.  */
        !          5020:       if (TREE_CODE (TREE_OPERAND (exp, 0)) == NOP_EXPR
        !          5021:          && TREE_CODE (type) == INTEGER_TYPE
        !          5022:          && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
        !          5023:              < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))))
        !          5024:          && ((TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
        !          5025:               && int_fits_type_p (TREE_OPERAND (exp, 1),
        !          5026:                                   TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
        !          5027:               /* Don't use a widening multiply if a shift will do.  */
        !          5028:               && ((GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1))))
        !          5029:                    > HOST_BITS_PER_WIDE_INT)
        !          5030:                   || exact_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))) < 0))
        !          5031:              ||
        !          5032:              (TREE_CODE (TREE_OPERAND (exp, 1)) == NOP_EXPR
        !          5033:               && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0)))
        !          5034:                   ==
        !          5035:                   TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))))
        !          5036:               /* If both operands are extended, they must either both
        !          5037:                  be zero-extended or both be sign-extended.  */
        !          5038:               && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0)))
        !          5039:                   ==
        !          5040:                   TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))))))
        !          5041:        {
        !          5042:          enum machine_mode innermode
        !          5043:            = TYPE_MODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)));
        !          5044:          this_optab = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
        !          5045:                        ? umul_widen_optab : smul_widen_optab);
        !          5046:          if (mode == GET_MODE_WIDER_MODE (innermode)
        !          5047:              && this_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
        !          5048:            {
        !          5049:              op0 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
        !          5050:                                 NULL_RTX, VOIDmode, 0);
        !          5051:              if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
        !          5052:                op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
        !          5053:                                   VOIDmode, 0);
        !          5054:              else
        !          5055:                op1 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 1), 0),
        !          5056:                                   NULL_RTX, VOIDmode, 0);
        !          5057:              goto binop2;
        !          5058:            }
        !          5059:        }
        !          5060:       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
        !          5061:       op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
        !          5062:       return expand_mult (mode, op0, op1, target, unsignedp);
        !          5063: 
        !          5064:     case TRUNC_DIV_EXPR:
        !          5065:     case FLOOR_DIV_EXPR:
        !          5066:     case CEIL_DIV_EXPR:
        !          5067:     case ROUND_DIV_EXPR:
        !          5068:     case EXACT_DIV_EXPR:
        !          5069:       preexpand_calls (exp);
        !          5070:       if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1)))
        !          5071:        subtarget = 0;
        !          5072:       /* Possible optimization: compute the dividend with EXPAND_SUM
        !          5073:         then if the divisor is constant can optimize the case
        !          5074:         where some terms of the dividend have coeffs divisible by it.  */
        !          5075:       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
        !          5076:       op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
        !          5077:       return expand_divmod (0, code, mode, op0, op1, target, unsignedp);
        !          5078: 
        !          5079:     case RDIV_EXPR:
        !          5080:       this_optab = flodiv_optab;
        !          5081:       goto binop;
        !          5082: 
        !          5083:     case TRUNC_MOD_EXPR:
        !          5084:     case FLOOR_MOD_EXPR:
        !          5085:     case CEIL_MOD_EXPR:
        !          5086:     case ROUND_MOD_EXPR:
        !          5087:       preexpand_calls (exp);
        !          5088:       if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1)))
        !          5089:        subtarget = 0;
        !          5090:       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
        !          5091:       op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
        !          5092:       return expand_divmod (1, code, mode, op0, op1, target, unsignedp);
        !          5093: 
        !          5094:     case FIX_ROUND_EXPR:
        !          5095:     case FIX_FLOOR_EXPR:
        !          5096:     case FIX_CEIL_EXPR:
        !          5097:       abort ();                        /* Not used for C.  */
        !          5098: 
        !          5099:     case FIX_TRUNC_EXPR:
        !          5100:       op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
        !          5101:       if (target == 0)
        !          5102:        target = gen_reg_rtx (mode);
        !          5103:       expand_fix (target, op0, unsignedp);
        !          5104:       return target;
        !          5105: 
        !          5106:     case FLOAT_EXPR:
        !          5107:       op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
        !          5108:       if (target == 0)
        !          5109:        target = gen_reg_rtx (mode);
        !          5110:       /* expand_float can't figure out what to do if FROM has VOIDmode.
        !          5111:         So give it the correct mode.  With -O, cse will optimize this.  */
        !          5112:       if (GET_MODE (op0) == VOIDmode)
        !          5113:        op0 = copy_to_mode_reg (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
        !          5114:                                op0);
        !          5115:       expand_float (target, op0,
        !          5116:                    TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
        !          5117:       return target;
        !          5118: 
        !          5119:     case NEGATE_EXPR:
        !          5120:       op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
        !          5121:       temp = expand_unop (mode, neg_optab, op0, target, 0);
        !          5122:       if (temp == 0)
        !          5123:        abort ();
        !          5124:       return temp;
        !          5125: 
        !          5126:     case ABS_EXPR:
        !          5127:       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
        !          5128: 
        !          5129:       /* Handle complex values specially.  */
        !          5130:       {
        !          5131:        enum machine_mode opmode
        !          5132:          = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
        !          5133: 
        !          5134:        if (GET_MODE_CLASS (opmode) == MODE_COMPLEX_INT
        !          5135:            || GET_MODE_CLASS (opmode) == MODE_COMPLEX_FLOAT)
        !          5136:          return expand_complex_abs (opmode, op0, target, unsignedp);
        !          5137:       }
        !          5138: 
        !          5139:       /* Unsigned abs is simply the operand.  Testing here means we don't
        !          5140:         risk generating incorrect code below.  */
        !          5141:       if (TREE_UNSIGNED (type))
        !          5142:        return op0;
        !          5143: 
        !          5144:       /* First try to do it with a special abs instruction.  */
        !          5145:       temp = expand_unop (mode, abs_optab, op0, target, 0);
        !          5146:       if (temp != 0)
        !          5147:        return temp;
        !          5148: 
        !          5149:       /* If this machine has expensive jumps, we can do integer absolute
        !          5150:         value of X as (((signed) x >> (W-1)) ^ x) - ((signed) x >> (W-1)),
        !          5151:         where W is the width of MODE.  */
        !          5152: 
        !          5153:       if (GET_MODE_CLASS (mode) == MODE_INT && BRANCH_COST >= 2)
        !          5154:        {
        !          5155:          rtx extended = expand_shift (RSHIFT_EXPR, mode, op0,
        !          5156:                                       size_int (GET_MODE_BITSIZE (mode) - 1),
        !          5157:                                       NULL_RTX, 0);
        !          5158: 
        !          5159:          temp = expand_binop (mode, xor_optab, extended, op0, target, 0,
        !          5160:                               OPTAB_LIB_WIDEN);
        !          5161:          if (temp != 0)
        !          5162:            temp = expand_binop (mode, sub_optab, temp, extended, target, 0,
        !          5163:                                 OPTAB_LIB_WIDEN);
        !          5164: 
        !          5165:          if (temp != 0)
        !          5166:            return temp;
        !          5167:        }
        !          5168: 
        !          5169:       /* If that does not win, use conditional jump and negate.  */
        !          5170:       target = original_target;
        !          5171:       temp = gen_label_rtx ();
        !          5172:       if (target == 0 || ! safe_from_p (target, TREE_OPERAND (exp, 0))
        !          5173:          || (GET_CODE (target) == MEM && MEM_VOLATILE_P (target))
        !          5174:          || (GET_CODE (target) == REG
        !          5175:              && REGNO (target) < FIRST_PSEUDO_REGISTER))
        !          5176:        target = gen_reg_rtx (mode);
        !          5177:       emit_move_insn (target, op0);
        !          5178:       emit_cmp_insn (target,
        !          5179:                     expand_expr (convert (type, integer_zero_node),
        !          5180:                                  NULL_RTX, VOIDmode, 0),
        !          5181:                     GE, NULL_RTX, mode, 0, 0);
        !          5182:       NO_DEFER_POP;
        !          5183:       emit_jump_insn (gen_bge (temp));
        !          5184:       op0 = expand_unop (mode, neg_optab, target, target, 0);
        !          5185:       if (op0 != target)
        !          5186:        emit_move_insn (target, op0);
        !          5187:       emit_label (temp);
        !          5188:       OK_DEFER_POP;
        !          5189:       return target;
        !          5190: 
        !          5191:     case MAX_EXPR:
        !          5192:     case MIN_EXPR:
        !          5193:       target = original_target;
        !          5194:       if (target == 0 || ! safe_from_p (target, TREE_OPERAND (exp, 1))
        !          5195:          || (GET_CODE (target) == MEM && MEM_VOLATILE_P (target))
        !          5196:          || (GET_CODE (target) == REG
        !          5197:              && REGNO (target) < FIRST_PSEUDO_REGISTER))
        !          5198:        target = gen_reg_rtx (mode);
        !          5199:       op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
        !          5200:       op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
        !          5201: 
        !          5202:       /* First try to do it with a special MIN or MAX instruction.
        !          5203:         If that does not win, use a conditional jump to select the proper
        !          5204:         value.  */
        !          5205:       this_optab = (TREE_UNSIGNED (type)
        !          5206:                    ? (code == MIN_EXPR ? umin_optab : umax_optab)
        !          5207:                    : (code == MIN_EXPR ? smin_optab : smax_optab));
        !          5208: 
        !          5209:       temp = expand_binop (mode, this_optab, op0, op1, target, unsignedp,
        !          5210:                           OPTAB_WIDEN);
        !          5211:       if (temp != 0)
        !          5212:        return temp;
        !          5213: 
        !          5214:       if (target != op0)
        !          5215:        emit_move_insn (target, op0);
        !          5216:       op0 = gen_label_rtx ();
        !          5217:       /* If this mode is an integer too wide to compare properly,
        !          5218:         compare word by word.  Rely on cse to optimize constant cases.  */
        !          5219:       if (GET_MODE_CLASS (mode) == MODE_INT
        !          5220:          && !can_compare_p (mode))
        !          5221:        {
        !          5222:          if (code == MAX_EXPR)
        !          5223:            do_jump_by_parts_greater_rtx (mode, TREE_UNSIGNED (type), target, op1, NULL, op0);
        !          5224:          else
        !          5225:            do_jump_by_parts_greater_rtx (mode, TREE_UNSIGNED (type), op1, target, NULL, op0);
        !          5226:          emit_move_insn (target, op1);
        !          5227:        }
        !          5228:       else
        !          5229:        {
        !          5230:          if (code == MAX_EXPR)
        !          5231:            temp = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1)))
        !          5232:                    ? compare_from_rtx (target, op1, GEU, 1, mode, NULL_RTX, 0)
        !          5233:                    : compare_from_rtx (target, op1, GE, 0, mode, NULL_RTX, 0));
        !          5234:          else
        !          5235:            temp = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1)))
        !          5236:                    ? compare_from_rtx (target, op1, LEU, 1, mode, NULL_RTX, 0)
        !          5237:                    : compare_from_rtx (target, op1, LE, 0, mode, NULL_RTX, 0));
        !          5238:          if (temp == const0_rtx)
        !          5239:            emit_move_insn (target, op1);
        !          5240:          else if (temp != const_true_rtx)
        !          5241:            {
        !          5242:              if (bcc_gen_fctn[(int) GET_CODE (temp)] != 0)
        !          5243:                emit_jump_insn ((*bcc_gen_fctn[(int) GET_CODE (temp)]) (op0));
        !          5244:              else
        !          5245:                abort ();
        !          5246:              emit_move_insn (target, op1);
        !          5247:            }
        !          5248:        }
        !          5249:       emit_label (op0);
        !          5250:       return target;
        !          5251: 
        !          5252: /* ??? Can optimize when the operand of this is a bitwise operation,
        !          5253:    by using a different bitwise operation.  */
        !          5254:     case BIT_NOT_EXPR:
        !          5255:       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
        !          5256:       temp = expand_unop (mode, one_cmpl_optab, op0, target, 1);
        !          5257:       if (temp == 0)
        !          5258:        abort ();
        !          5259:       return temp;
        !          5260: 
        !          5261:     case FFS_EXPR:
        !          5262:       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
        !          5263:       temp = expand_unop (mode, ffs_optab, op0, target, 1);
        !          5264:       if (temp == 0)
        !          5265:        abort ();
        !          5266:       return temp;
        !          5267: 
        !          5268: /* ??? Can optimize bitwise operations with one arg constant.
        !          5269:    Can optimize (a bitwise1 n) bitwise2 (a bitwise3 b)
        !          5270:    and (a bitwise1 b) bitwise2 b (etc)
        !          5271:    but that is probably not worth while.  */
        !          5272: 
        !          5273: /* BIT_AND_EXPR is for bitwise anding.
        !          5274:    TRUTH_AND_EXPR is for anding two boolean values
        !          5275:    when we want in all cases to compute both of them.
        !          5276:    In general it is fastest to do TRUTH_AND_EXPR by
        !          5277:    computing both operands as actual zero-or-1 values
        !          5278:    and then bitwise anding.  In cases where there cannot
        !          5279:    be any side effects, better code would be made by
        !          5280:    treating TRUTH_AND_EXPR like TRUTH_ANDIF_EXPR;
        !          5281:    but the question is how to recognize those cases.  */
        !          5282: 
        !          5283:       /* TRUTH_AND_EXPR can have a result whose mode doesn't match
        !          5284:         th operands.  If so, don't use our target.  */
        !          5285:     case TRUTH_AND_EXPR:
        !          5286:       if (mode != TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
        !          5287:        subtarget = 0;
        !          5288:     case BIT_AND_EXPR:
        !          5289:       this_optab = and_optab;
        !          5290:       goto binop;
        !          5291: 
        !          5292: /* See comment above about TRUTH_AND_EXPR; it applies here too.  */
        !          5293:     case TRUTH_OR_EXPR:
        !          5294:       if (mode != TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
        !          5295:        subtarget = 0;
        !          5296:     case BIT_IOR_EXPR:
        !          5297:       this_optab = ior_optab;
        !          5298:       goto binop;
        !          5299: 
        !          5300:     case TRUTH_XOR_EXPR:
        !          5301:       if (mode != TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
        !          5302:        subtarget = 0;
        !          5303:     case BIT_XOR_EXPR:
        !          5304:       this_optab = xor_optab;
        !          5305:       goto binop;
        !          5306: 
        !          5307:     case LSHIFT_EXPR:
        !          5308:     case RSHIFT_EXPR:
        !          5309:     case LROTATE_EXPR:
        !          5310:     case RROTATE_EXPR:
        !          5311:       preexpand_calls (exp);
        !          5312:       if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1)))
        !          5313:        subtarget = 0;
        !          5314:       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
        !          5315:       return expand_shift (code, mode, op0, TREE_OPERAND (exp, 1), target,
        !          5316:                           unsignedp);
        !          5317: 
        !          5318: /* Could determine the answer when only additive constants differ.
        !          5319:    Also, the addition of one can be handled by changing the condition.  */
        !          5320:     case LT_EXPR:
        !          5321:     case LE_EXPR:
        !          5322:     case GT_EXPR:
        !          5323:     case GE_EXPR:
        !          5324:     case EQ_EXPR:
        !          5325:     case NE_EXPR:
        !          5326:       preexpand_calls (exp);
        !          5327:       temp = do_store_flag (exp, target, tmode != VOIDmode ? tmode : mode, 0);
        !          5328:       if (temp != 0)
        !          5329:        return temp;
        !          5330:       /* For foo != 0, load foo, and if it is nonzero load 1 instead. */
        !          5331:       if (code == NE_EXPR && integer_zerop (TREE_OPERAND (exp, 1))
        !          5332:          && original_target
        !          5333:          && GET_CODE (original_target) == REG
        !          5334:          && (GET_MODE (original_target)
        !          5335:              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
        !          5336:        {
        !          5337:          temp = expand_expr (TREE_OPERAND (exp, 0), original_target, VOIDmode, 0);
        !          5338:          if (temp != original_target)
        !          5339:            temp = copy_to_reg (temp);
        !          5340:          op1 = gen_label_rtx ();
        !          5341:          emit_cmp_insn (temp, const0_rtx, EQ, NULL_RTX,
        !          5342:                         GET_MODE (temp), unsignedp, 0);
        !          5343:          emit_jump_insn (gen_beq (op1));
        !          5344:          emit_move_insn (temp, const1_rtx);
        !          5345:          emit_label (op1);
        !          5346:          return temp;
        !          5347:        }
        !          5348:       /* If no set-flag instruction, must generate a conditional
        !          5349:         store into a temporary variable.  Drop through
        !          5350:         and handle this like && and ||.  */
        !          5351: 
        !          5352:     case TRUTH_ANDIF_EXPR:
        !          5353:     case TRUTH_ORIF_EXPR:
        !          5354:       if (! ignore
        !          5355:          && (target == 0 || ! safe_from_p (target, exp)
        !          5356:              /* Make sure we don't have a hard reg (such as function's return
        !          5357:                 value) live across basic blocks, if not optimizing.  */
        !          5358:              || (!optimize && GET_CODE (target) == REG
        !          5359:                  && REGNO (target) < FIRST_PSEUDO_REGISTER)))
        !          5360:        target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
        !          5361: 
        !          5362:       if (target)
        !          5363:        emit_clr_insn (target);
        !          5364: 
        !          5365:       op1 = gen_label_rtx ();
        !          5366:       jumpifnot (exp, op1);
        !          5367: 
        !          5368:       if (target)
        !          5369:        emit_0_to_1_insn (target);
        !          5370: 
        !          5371:       emit_label (op1);
        !          5372:       return ignore ? const0_rtx : target;
        !          5373: 
        !          5374:     case TRUTH_NOT_EXPR:
        !          5375:       op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
        !          5376:       /* The parser is careful to generate TRUTH_NOT_EXPR
        !          5377:         only with operands that are always zero or one.  */
        !          5378:       temp = expand_binop (mode, xor_optab, op0, const1_rtx,
        !          5379:                           target, 1, OPTAB_LIB_WIDEN);
        !          5380:       if (temp == 0)
        !          5381:        abort ();
        !          5382:       return temp;
        !          5383: 
        !          5384:     case COMPOUND_EXPR:
        !          5385:       expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
        !          5386:       emit_queue ();
        !          5387:       return expand_expr (TREE_OPERAND (exp, 1),
        !          5388:                          (ignore ? const0_rtx : target),
        !          5389:                          VOIDmode, 0);
        !          5390: 
        !          5391:     case COND_EXPR:
        !          5392:       {
        !          5393:        /* Note that COND_EXPRs whose type is a structure or union
        !          5394:           are required to be constructed to contain assignments of
        !          5395:           a temporary variable, so that we can evaluate them here
        !          5396:           for side effect only.  If type is void, we must do likewise.  */
        !          5397: 
        !          5398:        /* If an arm of the branch requires a cleanup,
        !          5399:           only that cleanup is performed.  */
        !          5400: 
        !          5401:        tree singleton = 0;
        !          5402:        tree binary_op = 0, unary_op = 0;
        !          5403:        tree old_cleanups = cleanups_this_call;
        !          5404:        cleanups_this_call = 0;
        !          5405: 
        !          5406:        /* If this is (A ? 1 : 0) and A is a condition, just evaluate it and
        !          5407:           convert it to our mode, if necessary.  */
        !          5408:        if (integer_onep (TREE_OPERAND (exp, 1))
        !          5409:            && integer_zerop (TREE_OPERAND (exp, 2))
        !          5410:            && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<')
        !          5411:          {
        !          5412:            if (ignore)
        !          5413:              {
        !          5414:                expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
        !          5415:                             modifier);
        !          5416:                return const0_rtx;
        !          5417:              }
        !          5418: 
        !          5419:            op0 = expand_expr (TREE_OPERAND (exp, 0), target, mode, modifier);
        !          5420:            if (GET_MODE (op0) == mode)
        !          5421:              return op0;
        !          5422:            if (target == 0)
        !          5423:              target = gen_reg_rtx (mode);
        !          5424:            convert_move (target, op0, unsignedp);
        !          5425:            return target;
        !          5426:          }
        !          5427: 
        !          5428:        /* If we are not to produce a result, we have no target.  Otherwise,
        !          5429:           if a target was specified use it; it will not be used as an
        !          5430:           intermediate target unless it is safe.  If no target, use a 
        !          5431:           temporary.  */
        !          5432: 
        !          5433:        if (ignore)
        !          5434:          temp = 0;
        !          5435:        else if (original_target
        !          5436:                 && safe_from_p (original_target, TREE_OPERAND (exp, 0)))
        !          5437:          temp = original_target;
        !          5438:        else if (mode == BLKmode)
        !          5439:          {
        !          5440:            if (TYPE_SIZE (type) == 0
        !          5441:                || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
        !          5442:              abort ();
        !          5443: 
        !          5444:            temp = assign_stack_temp (BLKmode,
        !          5445:                                      (TREE_INT_CST_LOW (TYPE_SIZE (type))
        !          5446:                                       + BITS_PER_UNIT - 1)
        !          5447:                                      / BITS_PER_UNIT, 0);
        !          5448:            MEM_IN_STRUCT_P (temp)
        !          5449:              = (TREE_CODE (type) == RECORD_TYPE
        !          5450:                 || TREE_CODE (type) == UNION_TYPE
        !          5451:                 || TREE_CODE (type) == QUAL_UNION_TYPE
        !          5452:                 || TREE_CODE (type) == ARRAY_TYPE);
        !          5453:          }
        !          5454:        else
        !          5455:          temp = gen_reg_rtx (mode);
        !          5456: 
        !          5457:        /* Check for X ? A + B : A.  If we have this, we can copy
        !          5458:           A to the output and conditionally add B.  Similarly for unary
        !          5459:           operations.  Don't do this if X has side-effects because
        !          5460:           those side effects might affect A or B and the "?" operation is
        !          5461:           a sequence point in ANSI.  (We test for side effects later.)  */
        !          5462: 
        !          5463:        if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 1))) == '2'
        !          5464:            && operand_equal_p (TREE_OPERAND (exp, 2),
        !          5465:                                TREE_OPERAND (TREE_OPERAND (exp, 1), 0), 0))
        !          5466:          singleton = TREE_OPERAND (exp, 2), binary_op = TREE_OPERAND (exp, 1);
        !          5467:        else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 2))) == '2'
        !          5468:                 && operand_equal_p (TREE_OPERAND (exp, 1),
        !          5469:                                     TREE_OPERAND (TREE_OPERAND (exp, 2), 0), 0))
        !          5470:          singleton = TREE_OPERAND (exp, 1), binary_op = TREE_OPERAND (exp, 2);
        !          5471:        else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 1))) == '1'
        !          5472:                 && operand_equal_p (TREE_OPERAND (exp, 2),
        !          5473:                                     TREE_OPERAND (TREE_OPERAND (exp, 1), 0), 0))
        !          5474:          singleton = TREE_OPERAND (exp, 2), unary_op = TREE_OPERAND (exp, 1);
        !          5475:        else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 2))) == '1'
        !          5476:                 && operand_equal_p (TREE_OPERAND (exp, 1),
        !          5477:                                     TREE_OPERAND (TREE_OPERAND (exp, 2), 0), 0))
        !          5478:          singleton = TREE_OPERAND (exp, 1), unary_op = TREE_OPERAND (exp, 2);
        !          5479: 
        !          5480:        /* If we had X ? A + 1 : A and we can do the test of X as a store-flag
        !          5481:           operation, do this as A + (X != 0).  Similarly for other simple
        !          5482:           binary operators.  */
        !          5483:        if (temp && singleton && binary_op
        !          5484:            && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))
        !          5485:            && (TREE_CODE (binary_op) == PLUS_EXPR
        !          5486:                || TREE_CODE (binary_op) == MINUS_EXPR
        !          5487:                || TREE_CODE (binary_op) == BIT_IOR_EXPR
        !          5488:                || TREE_CODE (binary_op) == BIT_XOR_EXPR
        !          5489:                || TREE_CODE (binary_op) == BIT_AND_EXPR)
        !          5490:            && integer_onep (TREE_OPERAND (binary_op, 1))
        !          5491:            && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<')
        !          5492:          {
        !          5493:            rtx result;
        !          5494:            optab boptab = (TREE_CODE (binary_op) == PLUS_EXPR ? add_optab
        !          5495:                            : TREE_CODE (binary_op) == MINUS_EXPR ? sub_optab
        !          5496:                            : TREE_CODE (binary_op) == BIT_IOR_EXPR ? ior_optab
        !          5497:                            : TREE_CODE (binary_op) == BIT_XOR_EXPR ? xor_optab
        !          5498:                            : and_optab);
        !          5499: 
        !          5500:            /* If we had X ? A : A + 1, do this as A + (X == 0).
        !          5501: 
        !          5502:               We have to invert the truth value here and then put it
        !          5503:               back later if do_store_flag fails.  We cannot simply copy
        !          5504:               TREE_OPERAND (exp, 0) to another variable and modify that
        !          5505:               because invert_truthvalue can modify the tree pointed to
        !          5506:               by its argument.  */
        !          5507:            if (singleton == TREE_OPERAND (exp, 1))
        !          5508:              TREE_OPERAND (exp, 0)
        !          5509:                = invert_truthvalue (TREE_OPERAND (exp, 0));
        !          5510: 
        !          5511:            result = do_store_flag (TREE_OPERAND (exp, 0),
        !          5512:                                    (safe_from_p (temp, singleton)
        !          5513:                                     ? temp : NULL_RTX),
        !          5514:                                    mode, BRANCH_COST <= 1);
        !          5515: 
        !          5516:            if (result)
        !          5517:              {
        !          5518:                op1 = expand_expr (singleton, NULL_RTX, VOIDmode, 0);
        !          5519:                return expand_binop (mode, boptab, op1, result, temp,
        !          5520:                                     unsignedp, OPTAB_LIB_WIDEN);
        !          5521:              }
        !          5522:            else if (singleton == TREE_OPERAND (exp, 1))
        !          5523:              TREE_OPERAND (exp, 0)
        !          5524:                = invert_truthvalue (TREE_OPERAND (exp, 0));
        !          5525:          }
        !          5526:            
        !          5527:        NO_DEFER_POP;
        !          5528:        op0 = gen_label_rtx ();
        !          5529: 
        !          5530:        if (singleton && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0)))
        !          5531:          {
        !          5532:            if (temp != 0)
        !          5533:              {
        !          5534:                /* If the target conflicts with the other operand of the
        !          5535:                   binary op, we can't use it.  Also, we can't use the target
        !          5536:                   if it is a hard register, because evaluating the condition
        !          5537:                   might clobber it.  */
        !          5538:                if ((binary_op
        !          5539:                     && ! safe_from_p (temp, TREE_OPERAND (binary_op, 1)))
        !          5540:                    || (GET_CODE (temp) == REG
        !          5541:                        && REGNO (temp) < FIRST_PSEUDO_REGISTER))
        !          5542:                  temp = gen_reg_rtx (mode);
        !          5543:                store_expr (singleton, temp, 0);
        !          5544:              }
        !          5545:            else
        !          5546:              expand_expr (singleton,
        !          5547:                           ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
        !          5548:            if (cleanups_this_call)
        !          5549:              {
        !          5550:                sorry ("aggregate value in COND_EXPR");
        !          5551:                cleanups_this_call = 0;
        !          5552:              }
        !          5553:            if (singleton == TREE_OPERAND (exp, 1))
        !          5554:              jumpif (TREE_OPERAND (exp, 0), op0);
        !          5555:            else
        !          5556:              jumpifnot (TREE_OPERAND (exp, 0), op0);
        !          5557: 
        !          5558:            if (binary_op && temp == 0)
        !          5559:              /* Just touch the other operand.  */
        !          5560:              expand_expr (TREE_OPERAND (binary_op, 1),
        !          5561:                           ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
        !          5562:            else if (binary_op)
        !          5563:              store_expr (build (TREE_CODE (binary_op), type,
        !          5564:                                 make_tree (type, temp),
        !          5565:                                 TREE_OPERAND (binary_op, 1)),
        !          5566:                          temp, 0);
        !          5567:            else
        !          5568:              store_expr (build1 (TREE_CODE (unary_op), type,
        !          5569:                                  make_tree (type, temp)),
        !          5570:                          temp, 0);
        !          5571:            op1 = op0;
        !          5572:          }
        !          5573: #if 0
        !          5574:        /* This is now done in jump.c and is better done there because it
        !          5575:           produces shorter register lifetimes.  */
        !          5576:           
        !          5577:        /* Check for both possibilities either constants or variables
        !          5578:           in registers (but not the same as the target!).  If so, can
        !          5579:           save branches by assigning one, branching, and assigning the
        !          5580:           other.  */
        !          5581:        else if (temp && GET_MODE (temp) != BLKmode
        !          5582:                 && (TREE_CONSTANT (TREE_OPERAND (exp, 1))
        !          5583:                     || ((TREE_CODE (TREE_OPERAND (exp, 1)) == PARM_DECL
        !          5584:                          || TREE_CODE (TREE_OPERAND (exp, 1)) == VAR_DECL)
        !          5585:                         && DECL_RTL (TREE_OPERAND (exp, 1))
        !          5586:                         && GET_CODE (DECL_RTL (TREE_OPERAND (exp, 1))) == REG
        !          5587:                         && DECL_RTL (TREE_OPERAND (exp, 1)) != temp))
        !          5588:                 && (TREE_CONSTANT (TREE_OPERAND (exp, 2))
        !          5589:                     || ((TREE_CODE (TREE_OPERAND (exp, 2)) == PARM_DECL
        !          5590:                          || TREE_CODE (TREE_OPERAND (exp, 2)) == VAR_DECL)
        !          5591:                         && DECL_RTL (TREE_OPERAND (exp, 2))
        !          5592:                         && GET_CODE (DECL_RTL (TREE_OPERAND (exp, 2))) == REG
        !          5593:                         && DECL_RTL (TREE_OPERAND (exp, 2)) != temp)))
        !          5594:          {
        !          5595:            if (GET_CODE (temp) == REG && REGNO (temp) < FIRST_PSEUDO_REGISTER)
        !          5596:              temp = gen_reg_rtx (mode);
        !          5597:            store_expr (TREE_OPERAND (exp, 2), temp, 0);
        !          5598:            jumpifnot (TREE_OPERAND (exp, 0), op0);
        !          5599:            store_expr (TREE_OPERAND (exp, 1), temp, 0);
        !          5600:            op1 = op0;
        !          5601:          }
        !          5602: #endif
        !          5603:        /* Check for A op 0 ? A : FOO and A op 0 ? FOO : A where OP is any
        !          5604:           comparison operator.  If we have one of these cases, set the
        !          5605:           output to A, branch on A (cse will merge these two references),
        !          5606:           then set the output to FOO.  */
        !          5607:        else if (temp
        !          5608:                 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<'
        !          5609:                 && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp, 0), 1))
        !          5610:                 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
        !          5611:                                     TREE_OPERAND (exp, 1), 0)
        !          5612:                 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))
        !          5613:                 && safe_from_p (temp, TREE_OPERAND (exp, 2)))
        !          5614:          {
        !          5615:            if (GET_CODE (temp) == REG && REGNO (temp) < FIRST_PSEUDO_REGISTER)
        !          5616:              temp = gen_reg_rtx (mode);
        !          5617:            store_expr (TREE_OPERAND (exp, 1), temp, 0);
        !          5618:            jumpif (TREE_OPERAND (exp, 0), op0);
        !          5619:            store_expr (TREE_OPERAND (exp, 2), temp, 0);
        !          5620:            op1 = op0;
        !          5621:          }
        !          5622:        else if (temp
        !          5623:                 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<'
        !          5624:                 && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp, 0), 1))
        !          5625:                 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
        !          5626:                                     TREE_OPERAND (exp, 2), 0)
        !          5627:                 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))
        !          5628:                 && safe_from_p (temp, TREE_OPERAND (exp, 1)))
        !          5629:          {
        !          5630:            if (GET_CODE (temp) == REG && REGNO (temp) < FIRST_PSEUDO_REGISTER)
        !          5631:              temp = gen_reg_rtx (mode);
        !          5632:            store_expr (TREE_OPERAND (exp, 2), temp, 0);
        !          5633:            jumpifnot (TREE_OPERAND (exp, 0), op0);
        !          5634:            store_expr (TREE_OPERAND (exp, 1), temp, 0);
        !          5635:            op1 = op0;
        !          5636:          }
        !          5637:        else
        !          5638:          {
        !          5639:            op1 = gen_label_rtx ();
        !          5640:            jumpifnot (TREE_OPERAND (exp, 0), op0);
        !          5641:            if (temp != 0)
        !          5642:              store_expr (TREE_OPERAND (exp, 1), temp, 0);
        !          5643:            else
        !          5644:              expand_expr (TREE_OPERAND (exp, 1),
        !          5645:                           ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
        !          5646:            if (cleanups_this_call)
        !          5647:              {
        !          5648:                sorry ("aggregate value in COND_EXPR");
        !          5649:                cleanups_this_call = 0;
        !          5650:              }
        !          5651: 
        !          5652:            emit_queue ();
        !          5653:            emit_jump_insn (gen_jump (op1));
        !          5654:            emit_barrier ();
        !          5655:            emit_label (op0);
        !          5656:            if (temp != 0)
        !          5657:              store_expr (TREE_OPERAND (exp, 2), temp, 0);
        !          5658:            else
        !          5659:              expand_expr (TREE_OPERAND (exp, 2),
        !          5660:                           ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
        !          5661:          }
        !          5662: 
        !          5663:        if (cleanups_this_call)
        !          5664:          {
        !          5665:            sorry ("aggregate value in COND_EXPR");
        !          5666:            cleanups_this_call = 0;
        !          5667:          }
        !          5668: 
        !          5669:        emit_queue ();
        !          5670:        emit_label (op1);
        !          5671:        OK_DEFER_POP;
        !          5672:        cleanups_this_call = old_cleanups;
        !          5673:        return temp;
        !          5674:       }
        !          5675: 
        !          5676:     case TARGET_EXPR:
        !          5677:       {
        !          5678:        /* Something needs to be initialized, but we didn't know
        !          5679:           where that thing was when building the tree.  For example,
        !          5680:           it could be the return value of a function, or a parameter
        !          5681:           to a function which lays down in the stack, or a temporary
        !          5682:           variable which must be passed by reference.
        !          5683: 
        !          5684:           We guarantee that the expression will either be constructed
        !          5685:           or copied into our original target.  */
        !          5686: 
        !          5687:        tree slot = TREE_OPERAND (exp, 0);
        !          5688:        tree exp1;
        !          5689: 
        !          5690:        if (TREE_CODE (slot) != VAR_DECL)
        !          5691:          abort ();
        !          5692: 
        !          5693:        if (target == 0)
        !          5694:          {
        !          5695:            if (DECL_RTL (slot) != 0)
        !          5696:              {
        !          5697:                target = DECL_RTL (slot);
        !          5698:                /* If we have already expanded the slot, so don't do
        !          5699:                   it again.  (mrs)  */
        !          5700:                if (TREE_OPERAND (exp, 1) == NULL_TREE)
        !          5701:                  return target;
        !          5702:              }
        !          5703:            else
        !          5704:              {
        !          5705:                target = assign_stack_temp (mode, int_size_in_bytes (type), 0);
        !          5706:                /* All temp slots at this level must not conflict.  */
        !          5707:                preserve_temp_slots (target);
        !          5708:                DECL_RTL (slot) = target;
        !          5709:              }
        !          5710: 
        !          5711:            /* We set IGNORE when we know that we're already
        !          5712:               doing this for a cleanup.  */
        !          5713:            if (ignore == 0)
        !          5714:              {
        !          5715:                /* Since SLOT is not known to the called function
        !          5716:                   to belong to its stack frame, we must build an explicit
        !          5717:                   cleanup.  This case occurs when we must build up a reference
        !          5718:                   to pass the reference as an argument.  In this case,
        !          5719:                   it is very likely that such a reference need not be
        !          5720:                   built here.  */
        !          5721: 
        !          5722:                if (TREE_OPERAND (exp, 2) == 0)
        !          5723:                  TREE_OPERAND (exp, 2) = maybe_build_cleanup (slot);
        !          5724:                if (TREE_OPERAND (exp, 2))
        !          5725:                  cleanups_this_call = tree_cons (NULL_TREE, TREE_OPERAND (exp, 2),
        !          5726:                                                  cleanups_this_call);
        !          5727:              }
        !          5728:          }
        !          5729:        else
        !          5730:          {
        !          5731:            /* This case does occur, when expanding a parameter which
        !          5732:               needs to be constructed on the stack.  The target
        !          5733:               is the actual stack address that we want to initialize.
        !          5734:               The function we call will perform the cleanup in this case.  */
        !          5735: 
        !          5736:            /* If we have already assigned it space, use that space,
        !          5737:               not target that we were passed in, as our target
        !          5738:               parameter is only a hint.  */
        !          5739:            if (DECL_RTL (slot) != 0)
        !          5740:               {
        !          5741:                 target = DECL_RTL (slot);
        !          5742:                 /* If we have already expanded the slot, so don't do
        !          5743:                    it again.  (mrs)  */
        !          5744:                 if (TREE_OPERAND (exp, 1) == NULL_TREE)
        !          5745:                   return target;
        !          5746:              }
        !          5747: 
        !          5748:            DECL_RTL (slot) = target;
        !          5749:          }
        !          5750: 
        !          5751:        exp1 = TREE_OPERAND (exp, 1);
        !          5752:        /* Mark it as expanded.  */
        !          5753:        TREE_OPERAND (exp, 1) = NULL_TREE;
        !          5754: 
        !          5755:        return expand_expr (exp1, target, tmode, modifier);
        !          5756:       }
        !          5757: 
        !          5758:     case INIT_EXPR:
        !          5759:       {
        !          5760:        tree lhs = TREE_OPERAND (exp, 0);
        !          5761:        tree rhs = TREE_OPERAND (exp, 1);
        !          5762:        tree noncopied_parts = 0;
        !          5763:        tree lhs_type = TREE_TYPE (lhs);
        !          5764: 
        !          5765:        temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0);
        !          5766:        if (TYPE_NONCOPIED_PARTS (lhs_type) != 0 && !fixed_type_p (rhs))
        !          5767:          noncopied_parts = init_noncopied_parts (stabilize_reference (lhs),
        !          5768:                                                  TYPE_NONCOPIED_PARTS (lhs_type));
        !          5769:        while (noncopied_parts != 0)
        !          5770:          {
        !          5771:            expand_assignment (TREE_VALUE (noncopied_parts),
        !          5772:                               TREE_PURPOSE (noncopied_parts), 0, 0);
        !          5773:            noncopied_parts = TREE_CHAIN (noncopied_parts);
        !          5774:          }
        !          5775:        return temp;
        !          5776:       }
        !          5777: 
        !          5778:     case MODIFY_EXPR:
        !          5779:       {
        !          5780:        /* If lhs is complex, expand calls in rhs before computing it.
        !          5781:           That's so we don't compute a pointer and save it over a call.
        !          5782:           If lhs is simple, compute it first so we can give it as a
        !          5783:           target if the rhs is just a call.  This avoids an extra temp and copy
        !          5784:           and that prevents a partial-subsumption which makes bad code.
        !          5785:           Actually we could treat component_ref's of vars like vars.  */
        !          5786: 
        !          5787:        tree lhs = TREE_OPERAND (exp, 0);
        !          5788:        tree rhs = TREE_OPERAND (exp, 1);
        !          5789:        tree noncopied_parts = 0;
        !          5790:        tree lhs_type = TREE_TYPE (lhs);
        !          5791: 
        !          5792:        temp = 0;
        !          5793: 
        !          5794:        if (TREE_CODE (lhs) != VAR_DECL
        !          5795:            && TREE_CODE (lhs) != RESULT_DECL
        !          5796:            && TREE_CODE (lhs) != PARM_DECL)
        !          5797:          preexpand_calls (exp);
        !          5798: 
        !          5799:        /* Check for |= or &= of a bitfield of size one into another bitfield
        !          5800:           of size 1.  In this case, (unless we need the result of the
        !          5801:           assignment) we can do this more efficiently with a
        !          5802:           test followed by an assignment, if necessary.
        !          5803: 
        !          5804:           ??? At this point, we can't get a BIT_FIELD_REF here.  But if
        !          5805:           things change so we do, this code should be enhanced to
        !          5806:           support it.  */
        !          5807:        if (ignore
        !          5808:            && TREE_CODE (lhs) == COMPONENT_REF
        !          5809:            && (TREE_CODE (rhs) == BIT_IOR_EXPR
        !          5810:                || TREE_CODE (rhs) == BIT_AND_EXPR)
        !          5811:            && TREE_OPERAND (rhs, 0) == lhs
        !          5812:            && TREE_CODE (TREE_OPERAND (rhs, 1)) == COMPONENT_REF
        !          5813:            && TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (lhs, 1))) == 1
        !          5814:            && TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs, 1), 1))) == 1)
        !          5815:          {
        !          5816:            rtx label = gen_label_rtx ();
        !          5817: 
        !          5818:            do_jump (TREE_OPERAND (rhs, 1),
        !          5819:                     TREE_CODE (rhs) == BIT_IOR_EXPR ? label : 0,
        !          5820:                     TREE_CODE (rhs) == BIT_AND_EXPR ? label : 0);
        !          5821:            expand_assignment (lhs, convert (TREE_TYPE (rhs),
        !          5822:                                             (TREE_CODE (rhs) == BIT_IOR_EXPR
        !          5823:                                              ? integer_one_node
        !          5824:                                              : integer_zero_node)),
        !          5825:                               0, 0);
        !          5826:            do_pending_stack_adjust ();
        !          5827:            emit_label (label);
        !          5828:            return const0_rtx;
        !          5829:          }
        !          5830: 
        !          5831:        if (TYPE_NONCOPIED_PARTS (lhs_type) != 0
        !          5832:            && ! (fixed_type_p (lhs) && fixed_type_p (rhs)))
        !          5833:          noncopied_parts = save_noncopied_parts (stabilize_reference (lhs),
        !          5834:                                                  TYPE_NONCOPIED_PARTS (lhs_type));
        !          5835: 
        !          5836:        temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0);
        !          5837:        while (noncopied_parts != 0)
        !          5838:          {
        !          5839:            expand_assignment (TREE_PURPOSE (noncopied_parts),
        !          5840:                               TREE_VALUE (noncopied_parts), 0, 0);
        !          5841:            noncopied_parts = TREE_CHAIN (noncopied_parts);
        !          5842:          }
        !          5843:        return temp;
        !          5844:       }
        !          5845: 
        !          5846:     case PREINCREMENT_EXPR:
        !          5847:     case PREDECREMENT_EXPR:
        !          5848:       return expand_increment (exp, 0);
        !          5849: 
        !          5850:     case POSTINCREMENT_EXPR:
        !          5851:     case POSTDECREMENT_EXPR:
        !          5852:       /* Faster to treat as pre-increment if result is not used.  */
        !          5853:       return expand_increment (exp, ! ignore);
        !          5854: 
        !          5855:     case ADDR_EXPR:
        !          5856:       /* Are we taking the address of a nested function?  */
        !          5857:       if (TREE_CODE (TREE_OPERAND (exp, 0)) == FUNCTION_DECL
        !          5858:          && decl_function_context (TREE_OPERAND (exp, 0)) != 0)
        !          5859:        {
        !          5860:          op0 = trampoline_address (TREE_OPERAND (exp, 0));
        !          5861:          op0 = force_operand (op0, target);
        !          5862:        }
        !          5863:       else
        !          5864:        {
        !          5865:          /* We make sure to pass const0_rtx down if we came in with
        !          5866:             ignore set, to avoid doing the cleanups twice for something.  */
        !          5867:          op0 = expand_expr (TREE_OPERAND (exp, 0),
        !          5868:                             ignore ? const0_rtx : NULL_RTX, VOIDmode,
        !          5869:                             (modifier == EXPAND_INITIALIZER
        !          5870:                              ? modifier : EXPAND_CONST_ADDRESS));
        !          5871: 
        !          5872:          /* We would like the object in memory.  If it is a constant,
        !          5873:             we can have it be statically allocated into memory.  For
        !          5874:             a non-constant (REG or SUBREG), we need to allocate some
        !          5875:             memory and store the value into it.  */
        !          5876: 
        !          5877:          if (CONSTANT_P (op0))
        !          5878:            op0 = force_const_mem (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
        !          5879:                                   op0);
        !          5880: 
        !          5881:          /* These cases happen in Fortran.  Is that legitimate?
        !          5882:             Should Fortran work in another way?
        !          5883:             Do they happen in C?  */
        !          5884:          if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
        !          5885:              || GET_CODE (op0) == CONCAT)
        !          5886:            {
        !          5887:              /* If this object is in a register, it must be not
        !          5888:                 be BLKmode. */
        !          5889:              tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
        !          5890:              enum machine_mode inner_mode = TYPE_MODE (inner_type);
        !          5891:              rtx memloc
        !          5892:                = assign_stack_temp (inner_mode,
        !          5893:                                     int_size_in_bytes (inner_type), 1);
        !          5894: 
        !          5895:              emit_move_insn (memloc, op0);
        !          5896:              op0 = memloc;
        !          5897:            }
        !          5898: 
        !          5899:          if (GET_CODE (op0) != MEM)
        !          5900:            abort ();
        !          5901:   
        !          5902:          if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
        !          5903:            return XEXP (op0, 0);
        !          5904:          op0 = force_operand (XEXP (op0, 0), target);
        !          5905:        }
        !          5906:       if (flag_force_addr && GET_CODE (op0) != REG)
        !          5907:        return force_reg (Pmode, op0);
        !          5908:       return op0;
        !          5909: 
        !          5910:     case ENTRY_VALUE_EXPR:
        !          5911:       abort ();
        !          5912: 
        !          5913:     /* COMPLEX type for Extended Pascal & Fortran  */
        !          5914:     case COMPLEX_EXPR:
        !          5915:       {
        !          5916:        enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
        !          5917: 
        !          5918:        rtx prev;
        !          5919: 
        !          5920:        /* Get the rtx code of the operands.  */
        !          5921:        op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
        !          5922:        op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
        !          5923: 
        !          5924:        if (! target)
        !          5925:          target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
        !          5926: 
        !          5927:        prev = get_last_insn ();
        !          5928: 
        !          5929:        /* Tell flow that the whole of the destination is being set.  */
        !          5930:        if (GET_CODE (target) == REG)
        !          5931:          emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
        !          5932: 
        !          5933:        /* Move the real (op0) and imaginary (op1) parts to their location.  */
        !          5934:        emit_move_insn (gen_realpart (mode, target), op0);
        !          5935:        emit_move_insn (gen_imagpart (mode, target), op1);
        !          5936: 
        !          5937:        /* Complex construction should appear as a single unit.  */
        !          5938:        if (GET_CODE (target) != CONCAT)
        !          5939:          /* If TARGET is a CONCAT, we got insns like RD = RS, ID = IS,
        !          5940:             each with a separate pseudo as destination.
        !          5941:             It's not correct for flow to treat them as a unit.  */
        !          5942:          group_insns (prev);
        !          5943: 
        !          5944:        return target;
        !          5945:       }
        !          5946: 
        !          5947:     case REALPART_EXPR:
        !          5948:       op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
        !          5949:       return gen_realpart (mode, op0);
        !          5950:       
        !          5951:     case IMAGPART_EXPR:
        !          5952:       op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
        !          5953:       return gen_imagpart (mode, op0);
        !          5954: 
        !          5955:     case CONJ_EXPR:
        !          5956:       {
        !          5957:        enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
        !          5958:        rtx imag_t;
        !          5959:        rtx prev;
        !          5960:        
        !          5961:        op0  = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
        !          5962: 
        !          5963:        if (! target)
        !          5964:          target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
        !          5965:                                                                    
        !          5966:        prev = get_last_insn ();
        !          5967: 
        !          5968:        /* Tell flow that the whole of the destination is being set.  */
        !          5969:        if (GET_CODE (target) == REG)
        !          5970:          emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
        !          5971: 
        !          5972:        /* Store the realpart and the negated imagpart to target.  */
        !          5973:        emit_move_insn (gen_realpart (mode, target), gen_realpart (mode, op0));
        !          5974: 
        !          5975:        imag_t = gen_imagpart (mode, target);
        !          5976:        temp   = expand_unop (mode, neg_optab,
        !          5977:                              gen_imagpart (mode, op0), imag_t, 0);
        !          5978:        if (temp != imag_t)
        !          5979:          emit_move_insn (imag_t, temp);
        !          5980: 
        !          5981:        /* Conjugate should appear as a single unit */
        !          5982:        if (GET_CODE (target) != CONCAT)
        !          5983:          /* If TARGET is a CONCAT, we got insns like RD = RS, ID = - IS,
        !          5984:             each with a separate pseudo as destination.
        !          5985:             It's not correct for flow to treat them as a unit.  */
        !          5986:          group_insns (prev);
        !          5987: 
        !          5988:        return target;
        !          5989:       }
        !          5990: 
        !          5991:     case ERROR_MARK:
        !          5992:       op0 = CONST0_RTX (tmode);
        !          5993:       if (op0 != 0)
        !          5994:        return op0;
        !          5995:       return const0_rtx;
        !          5996: 
        !          5997:     default:
        !          5998:       return (*lang_expand_expr) (exp, original_target, tmode, modifier);
        !          5999:     }
        !          6000: 
        !          6001:   /* Here to do an ordinary binary operator, generating an instruction
        !          6002:      from the optab already placed in `this_optab'.  */
        !          6003:  binop:
        !          6004:   preexpand_calls (exp);
        !          6005:   if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1)))
        !          6006:     subtarget = 0;
        !          6007:   op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
        !          6008:   op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
        !          6009:  binop2:
        !          6010:   temp = expand_binop (mode, this_optab, op0, op1, target,
        !          6011:                       unsignedp, OPTAB_LIB_WIDEN);
        !          6012:   if (temp == 0)
        !          6013:     abort ();
        !          6014:   return temp;
        !          6015: }
        !          6016: 
        !          6017: 
        !          6018: /* Emit bytecode to evaluate the given expression EXP to the stack. */
        !          6019: void
        !          6020: bc_expand_expr (exp)
        !          6021:     tree exp;
        !          6022: {
        !          6023:   enum tree_code code;
        !          6024:   tree type, arg0;
        !          6025:   rtx r;
        !          6026:   struct binary_operator *binoptab;
        !          6027:   struct unary_operator *unoptab;
        !          6028:   struct increment_operator *incroptab;
        !          6029:   struct bc_label *lab, *lab1;
        !          6030:   enum bytecode_opcode opcode;
        !          6031:   
        !          6032:   
        !          6033:   code = TREE_CODE (exp);
        !          6034:   
        !          6035:   switch (code)
        !          6036:     {
        !          6037:     case PARM_DECL:
        !          6038:       
        !          6039:       if (DECL_RTL (exp) == 0)
        !          6040:        {
        !          6041:          error_with_decl (exp, "prior parameter's size depends on `%s'");
        !          6042:          return;
        !          6043:        }
        !          6044:       
        !          6045:       bc_load_parmaddr (DECL_RTL (exp));
        !          6046:       bc_load_memory (TREE_TYPE (exp), exp);
        !          6047:       
        !          6048:       return;
        !          6049:       
        !          6050:     case VAR_DECL:
        !          6051:       
        !          6052:       if (DECL_RTL (exp) == 0)
        !          6053:        abort ();
        !          6054:       
        !          6055: #if 0
        !          6056:       if (BYTECODE_LABEL (DECL_RTL (exp)))
        !          6057:        bc_load_externaddr (DECL_RTL (exp));
        !          6058:       else
        !          6059:        bc_load_localaddr (DECL_RTL (exp));
        !          6060: #endif
        !          6061:       if (TREE_PUBLIC (exp))
        !          6062:        bc_load_externaddr_id (DECL_ASSEMBLER_NAME (exp),
        !          6063:                               BYTECODE_BC_LABEL (DECL_RTL (exp))->offset);
        !          6064:       else
        !          6065:        bc_load_localaddr (DECL_RTL (exp));
        !          6066:       
        !          6067:       bc_load_memory (TREE_TYPE (exp), exp);
        !          6068:       return;
        !          6069:       
        !          6070:     case INTEGER_CST:
        !          6071:       
        !          6072: #ifdef DEBUG_PRINT_CODE
        !          6073:       fprintf (stderr, " [%x]\n", TREE_INT_CST_LOW (exp));
        !          6074: #endif
        !          6075:       bc_emit_instruction (mode_to_const_map[(int) (DECL_BIT_FIELD (exp)
        !          6076:                                             ? SImode
        !          6077:                                             : TYPE_MODE (TREE_TYPE (exp)))],
        !          6078:                           (HOST_WIDE_INT) TREE_INT_CST_LOW (exp));
        !          6079:       return;
        !          6080:       
        !          6081:     case REAL_CST:
        !          6082:       
        !          6083: #if 0
        !          6084: #ifdef DEBUG_PRINT_CODE
        !          6085:       fprintf (stderr, " [%g]\n", (double) TREE_INT_CST_LOW (exp));
        !          6086: #endif
        !          6087:       /* FIX THIS: find a better way to pass real_cst's. -bson */
        !          6088:       bc_emit_instruction (mode_to_const_map[TYPE_MODE (TREE_TYPE (exp))],
        !          6089:                           (double) TREE_REAL_CST (exp));
        !          6090: #else
        !          6091:       abort ();
        !          6092: #endif
        !          6093: 
        !          6094:       return;
        !          6095:       
        !          6096:     case CALL_EXPR:
        !          6097:       
        !          6098:       /* We build a call description vector describing the type of
        !          6099:         the return value and of the arguments; this call vector,
        !          6100:         together with a pointer to a location for the return value
        !          6101:         and the base of the argument list, is passed to the low
        !          6102:         level machine dependent call subroutine, which is responsible
        !          6103:         for putting the arguments wherever real functions expect
        !          6104:         them, as well as getting the return value back.  */
        !          6105:       {
        !          6106:        tree calldesc = 0, arg;
        !          6107:        int nargs = 0, i;
        !          6108:        rtx retval;
        !          6109:        
        !          6110:        /* Push the evaluated args on the evaluation stack in reverse
        !          6111:           order.  Also make an entry for each arg in the calldesc
        !          6112:           vector while we're at it.  */
        !          6113:        
        !          6114:        TREE_OPERAND (exp, 1) = nreverse (TREE_OPERAND (exp, 1));
        !          6115:        
        !          6116:        for (arg = TREE_OPERAND (exp, 1); arg; arg = TREE_CHAIN (arg))
        !          6117:          {
        !          6118:            ++nargs;
        !          6119:            bc_expand_expr (TREE_VALUE (arg));
        !          6120:            
        !          6121:            calldesc = tree_cons ((tree) 0,
        !          6122:                                  size_in_bytes (TREE_TYPE (TREE_VALUE (arg))),
        !          6123:                                  calldesc);
        !          6124:            calldesc = tree_cons ((tree) 0,
        !          6125:                                  bc_runtime_type_code (TREE_TYPE (TREE_VALUE (arg))),
        !          6126:                                  calldesc);
        !          6127:          }
        !          6128:        
        !          6129:        TREE_OPERAND (exp, 1) = nreverse (TREE_OPERAND (exp, 1));
        !          6130:        
        !          6131:        /* Allocate a location for the return value and push its
        !          6132:           address on the evaluation stack.  Also make an entry
        !          6133:           at the front of the calldesc for the return value type. */
        !          6134:        
        !          6135:        type = TREE_TYPE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))));
        !          6136:        retval = bc_allocate_local (int_size_in_bytes (type), TYPE_ALIGN (type));
        !          6137:        bc_load_localaddr (retval);
        !          6138:        
        !          6139:        calldesc = tree_cons ((tree) 0, size_in_bytes (type), calldesc);
        !          6140:        calldesc = tree_cons ((tree) 0, bc_runtime_type_code (type), calldesc);
        !          6141:        
        !          6142:        /* Prepend the argument count.  */
        !          6143:        calldesc = tree_cons ((tree) 0,
        !          6144:                              build_int_2 (nargs, 0),
        !          6145:                              calldesc);
        !          6146:        
        !          6147:        /* Push the address of the call description vector on the stack.  */
        !          6148:        calldesc = build_nt (CONSTRUCTOR, (tree) 0, calldesc);
        !          6149:        TREE_TYPE (calldesc) = build_array_type (integer_type_node,
        !          6150:                                                 build_index_type (build_int_2 (nargs * 2, 0)));
        !          6151:        r = output_constant_def (calldesc);
        !          6152:        bc_load_externaddr (r);
        !          6153:        
        !          6154:        /* Push the address of the function to be called. */
        !          6155:        bc_expand_expr (TREE_OPERAND (exp, 0));
        !          6156:        
        !          6157:        /* Call the function, popping its address and the calldesc vector
        !          6158:           address off the evaluation stack in the process.  */
        !          6159:        bc_emit_instruction (call);
        !          6160:        
        !          6161:        /* Pop the arguments off the stack.  */
        !          6162:        bc_adjust_stack (nargs);
        !          6163:        
        !          6164:        /* Load the return value onto the stack.  */
        !          6165:        bc_load_localaddr (retval);
        !          6166:        bc_load_memory (type, TREE_OPERAND (exp, 0));
        !          6167:       }
        !          6168:       return;
        !          6169:       
        !          6170:     case SAVE_EXPR:
        !          6171:       
        !          6172:       if (!SAVE_EXPR_RTL (exp))
        !          6173:        {
        !          6174:          /* First time around: copy to local variable */
        !          6175:          SAVE_EXPR_RTL (exp) = bc_allocate_local (int_size_in_bytes (TREE_TYPE (exp)),
        !          6176:                                                   TYPE_ALIGN (TREE_TYPE(exp)));
        !          6177:          bc_expand_expr (TREE_OPERAND (exp, 0));
        !          6178:          bc_emit_instruction (duplicate);
        !          6179:          
        !          6180:          bc_load_localaddr (SAVE_EXPR_RTL (exp));
        !          6181:          bc_store_memory (TREE_TYPE (exp), TREE_OPERAND (exp, 0));
        !          6182:        }
        !          6183:       else
        !          6184:        {
        !          6185:          /* Consecutive reference: use saved copy */
        !          6186:          bc_load_localaddr (SAVE_EXPR_RTL (exp));
        !          6187:          bc_load_memory (TREE_TYPE (exp), TREE_OPERAND (exp, 0));
        !          6188:        }
        !          6189:       return;
        !          6190:       
        !          6191: #if 0
        !          6192:       /* FIXME: the XXXX_STMT codes have been removed in GCC2, but
        !          6193:         how are they handled instead? */
        !          6194:     case LET_STMT:
        !          6195:       
        !          6196:       TREE_USED (exp) = 1;
        !          6197:       bc_expand_expr (STMT_BODY (exp));
        !          6198:       return;
        !          6199: #endif
        !          6200:       
        !          6201:     case NOP_EXPR:
        !          6202:     case CONVERT_EXPR:
        !          6203:       
        !          6204:       bc_expand_expr (TREE_OPERAND (exp, 0));
        !          6205:       bc_expand_conversion (TREE_TYPE (TREE_OPERAND (exp, 0)), TREE_TYPE (exp));
        !          6206:       return;
        !          6207:       
        !          6208:     case MODIFY_EXPR:
        !          6209:       
        !          6210:       expand_assignment (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1), 0, 0);
        !          6211:       return;
        !          6212:       
        !          6213:     case ADDR_EXPR:
        !          6214:       
        !          6215:       bc_expand_address (TREE_OPERAND (exp, 0));
        !          6216:       return;
        !          6217:       
        !          6218:     case INDIRECT_REF:
        !          6219:       
        !          6220:       bc_expand_expr (TREE_OPERAND (exp, 0));
        !          6221:       bc_load_memory (TREE_TYPE (exp), TREE_OPERAND (exp, 0));
        !          6222:       return;
        !          6223:       
        !          6224:     case ARRAY_REF:
        !          6225:       
        !          6226:       bc_expand_expr (bc_canonicalize_array_ref (exp));
        !          6227:       return;
        !          6228:       
        !          6229:     case COMPONENT_REF:
        !          6230:       
        !          6231:       bc_expand_component_address (exp);
        !          6232:       
        !          6233:       /* If we have a bitfield, generate a proper load */
        !          6234:       bc_load_memory (TREE_TYPE (TREE_OPERAND (exp, 1)), TREE_OPERAND (exp, 1));
        !          6235:       return;
        !          6236:       
        !          6237:     case COMPOUND_EXPR:
        !          6238:       
        !          6239:       bc_expand_expr (TREE_OPERAND (exp, 0));
        !          6240:       bc_emit_instruction (drop);
        !          6241:       bc_expand_expr (TREE_OPERAND (exp, 1));
        !          6242:       return;
        !          6243:       
        !          6244:     case COND_EXPR:
        !          6245:       
        !          6246:       bc_expand_expr (TREE_OPERAND (exp, 0));
        !          6247:       bc_expand_truth_conversion (TREE_TYPE (TREE_OPERAND (exp, 0)));
        !          6248:       lab = bc_get_bytecode_label ();
        !          6249:       bc_emit_bytecode (xjumpifnot);
        !          6250:       bc_emit_bytecode_labelref (lab);
        !          6251:       
        !          6252: #ifdef DEBUG_PRINT_CODE
        !          6253:       fputc ('\n', stderr);
        !          6254: #endif
        !          6255:       bc_expand_expr (TREE_OPERAND (exp, 1));
        !          6256:       lab1 = bc_get_bytecode_label ();
        !          6257:       bc_emit_bytecode (jump);
        !          6258:       bc_emit_bytecode_labelref (lab1);
        !          6259:       
        !          6260: #ifdef DEBUG_PRINT_CODE
        !          6261:       fputc ('\n', stderr);
        !          6262: #endif
        !          6263:       
        !          6264:       bc_emit_bytecode_labeldef (lab);
        !          6265:       bc_expand_expr (TREE_OPERAND (exp, 2));
        !          6266:       bc_emit_bytecode_labeldef (lab1);
        !          6267:       return;
        !          6268:       
        !          6269:     case TRUTH_ANDIF_EXPR:
        !          6270:       
        !          6271:       opcode = xjumpifnot;
        !          6272:       goto andorif;
        !          6273:       
        !          6274:     case TRUTH_ORIF_EXPR:
        !          6275:       
        !          6276:       opcode = xjumpif;
        !          6277:       goto andorif;
        !          6278:       
        !          6279:     case PLUS_EXPR:
        !          6280:       
        !          6281:       binoptab = optab_plus_expr;
        !          6282:       goto binop;
        !          6283:       
        !          6284:     case MINUS_EXPR:
        !          6285:       
        !          6286:       binoptab = optab_minus_expr;
        !          6287:       goto binop;
        !          6288:       
        !          6289:     case MULT_EXPR:
        !          6290:       
        !          6291:       binoptab = optab_mult_expr;
        !          6292:       goto binop;
        !          6293:       
        !          6294:     case TRUNC_DIV_EXPR:
        !          6295:     case FLOOR_DIV_EXPR:
        !          6296:     case CEIL_DIV_EXPR:
        !          6297:     case ROUND_DIV_EXPR:
        !          6298:     case EXACT_DIV_EXPR:
        !          6299:       
        !          6300:       binoptab = optab_trunc_div_expr;
        !          6301:       goto binop;
        !          6302:       
        !          6303:     case TRUNC_MOD_EXPR:
        !          6304:     case FLOOR_MOD_EXPR:
        !          6305:     case CEIL_MOD_EXPR:
        !          6306:     case ROUND_MOD_EXPR:
        !          6307:       
        !          6308:       binoptab = optab_trunc_mod_expr;
        !          6309:       goto binop;
        !          6310:       
        !          6311:     case FIX_ROUND_EXPR:
        !          6312:     case FIX_FLOOR_EXPR:
        !          6313:     case FIX_CEIL_EXPR:
        !          6314:       abort ();                        /* Not used for C.  */
        !          6315:       
        !          6316:     case FIX_TRUNC_EXPR:
        !          6317:     case FLOAT_EXPR:
        !          6318:     case MAX_EXPR:
        !          6319:     case MIN_EXPR:
        !          6320:     case FFS_EXPR:
        !          6321:     case LROTATE_EXPR:
        !          6322:     case RROTATE_EXPR:
        !          6323:       abort ();                        /* FIXME */
        !          6324:       
        !          6325:     case RDIV_EXPR:
        !          6326:       
        !          6327:       binoptab = optab_rdiv_expr;
        !          6328:       goto binop;
        !          6329:       
        !          6330:     case BIT_AND_EXPR:
        !          6331:       
        !          6332:       binoptab = optab_bit_and_expr;
        !          6333:       goto binop;
        !          6334:       
        !          6335:     case BIT_IOR_EXPR:
        !          6336:       
        !          6337:       binoptab = optab_bit_ior_expr;
        !          6338:       goto binop;
        !          6339:       
        !          6340:     case BIT_XOR_EXPR:
        !          6341:       
        !          6342:       binoptab = optab_bit_xor_expr;
        !          6343:       goto binop;
        !          6344:       
        !          6345:     case LSHIFT_EXPR:
        !          6346:       
        !          6347:       binoptab = optab_lshift_expr;
        !          6348:       goto binop;
        !          6349:       
        !          6350:     case RSHIFT_EXPR:
        !          6351:       
        !          6352:       binoptab = optab_rshift_expr;
        !          6353:       goto binop;
        !          6354:       
        !          6355:     case TRUTH_AND_EXPR:
        !          6356:       
        !          6357:       binoptab = optab_truth_and_expr;
        !          6358:       goto binop;
        !          6359:       
        !          6360:     case TRUTH_OR_EXPR:
        !          6361:       
        !          6362:       binoptab = optab_truth_or_expr;
        !          6363:       goto binop;
        !          6364:       
        !          6365:     case LT_EXPR:
        !          6366:       
        !          6367:       binoptab = optab_lt_expr;
        !          6368:       goto binop;
        !          6369:       
        !          6370:     case LE_EXPR:
        !          6371:       
        !          6372:       binoptab = optab_le_expr;
        !          6373:       goto binop;
        !          6374:       
        !          6375:     case GE_EXPR:
        !          6376:       
        !          6377:       binoptab = optab_ge_expr;
        !          6378:       goto binop;
        !          6379:       
        !          6380:     case GT_EXPR:
        !          6381:       
        !          6382:       binoptab = optab_gt_expr;
        !          6383:       goto binop;
        !          6384:       
        !          6385:     case EQ_EXPR:
        !          6386:       
        !          6387:       binoptab = optab_eq_expr;
        !          6388:       goto binop;
        !          6389:       
        !          6390:     case NE_EXPR:
        !          6391:       
        !          6392:       binoptab = optab_ne_expr;
        !          6393:       goto binop;
        !          6394:       
        !          6395:     case NEGATE_EXPR:
        !          6396:       
        !          6397:       unoptab = optab_negate_expr;
        !          6398:       goto unop;
        !          6399:       
        !          6400:     case BIT_NOT_EXPR:
        !          6401:       
        !          6402:       unoptab = optab_bit_not_expr;
        !          6403:       goto unop;
        !          6404:       
        !          6405:     case TRUTH_NOT_EXPR:
        !          6406:       
        !          6407:       unoptab = optab_truth_not_expr;
        !          6408:       goto unop;
        !          6409:       
        !          6410:     case PREDECREMENT_EXPR:
        !          6411:       
        !          6412:       incroptab = optab_predecrement_expr;
        !          6413:       goto increment;
        !          6414:       
        !          6415:     case PREINCREMENT_EXPR:
        !          6416:       
        !          6417:       incroptab = optab_preincrement_expr;
        !          6418:       goto increment;
        !          6419:       
        !          6420:     case POSTDECREMENT_EXPR:
        !          6421:       
        !          6422:       incroptab = optab_postdecrement_expr;
        !          6423:       goto increment;
        !          6424:       
        !          6425:     case POSTINCREMENT_EXPR:
        !          6426:       
        !          6427:       incroptab = optab_postincrement_expr;
        !          6428:       goto increment;
        !          6429:       
        !          6430:     case CONSTRUCTOR:
        !          6431:       
        !          6432:       bc_expand_constructor (exp);
        !          6433:       return;
        !          6434:       
        !          6435:     case ERROR_MARK:
        !          6436:     case RTL_EXPR:
        !          6437:       
        !          6438:       return;
        !          6439:       
        !          6440:     case BIND_EXPR:
        !          6441:       {
        !          6442:        tree vars = TREE_OPERAND (exp, 0);
        !          6443:        int vars_need_expansion = 0;
        !          6444:        
        !          6445:        /* Need to open a binding contour here because
        !          6446:           if there are any cleanups they most be contained here.  */
        !          6447:        expand_start_bindings (0);
        !          6448:        
        !          6449:        /* Mark the corresponding BLOCK for output.  */
        !          6450:        if (TREE_OPERAND (exp, 2) != 0)
        !          6451:          TREE_USED (TREE_OPERAND (exp, 2)) = 1;
        !          6452:        
        !          6453:        /* If VARS have not yet been expanded, expand them now.  */
        !          6454:        while (vars)
        !          6455:          {
        !          6456:            if (DECL_RTL (vars) == 0)
        !          6457:              {
        !          6458:                vars_need_expansion = 1;
        !          6459:                bc_expand_decl (vars, 0);
        !          6460:              }
        !          6461:            bc_expand_decl_init (vars);
        !          6462:            vars = TREE_CHAIN (vars);
        !          6463:          }
        !          6464:        
        !          6465:        bc_expand_expr (TREE_OPERAND (exp, 1));
        !          6466:        
        !          6467:        expand_end_bindings (TREE_OPERAND (exp, 0), 0, 0);
        !          6468:        
        !          6469:        return;
        !          6470:       }
        !          6471:     }
        !          6472:   
        !          6473:   abort ();
        !          6474:   
        !          6475:  binop:
        !          6476:   
        !          6477:   bc_expand_binary_operation (binoptab, TREE_TYPE (exp),
        !          6478:                              TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1));
        !          6479:   return;
        !          6480:   
        !          6481:   
        !          6482:  unop:
        !          6483:   
        !          6484:   bc_expand_unary_operation (unoptab, TREE_TYPE (exp), TREE_OPERAND (exp, 0));
        !          6485:   return;
        !          6486:   
        !          6487:   
        !          6488:  andorif:
        !          6489:   
        !          6490:   bc_expand_expr (TREE_OPERAND (exp, 0));
        !          6491:   bc_expand_truth_conversion (TREE_TYPE (TREE_OPERAND (exp, 0)));
        !          6492:   lab = bc_get_bytecode_label ();
        !          6493:   
        !          6494:   bc_emit_instruction (duplicate);
        !          6495:   bc_emit_bytecode (opcode);
        !          6496:   bc_emit_bytecode_labelref (lab);
        !          6497:   
        !          6498: #ifdef DEBUG_PRINT_CODE
        !          6499:   fputc ('\n', stderr);
        !          6500: #endif
        !          6501:   
        !          6502:   bc_emit_instruction (drop);
        !          6503:   
        !          6504:   bc_expand_expr (TREE_OPERAND (exp, 1));
        !          6505:   bc_expand_truth_conversion (TREE_TYPE (TREE_OPERAND (exp, 1)));
        !          6506:   bc_emit_bytecode_labeldef (lab);
        !          6507:   return;
        !          6508:   
        !          6509:   
        !          6510:  increment:
        !          6511:   
        !          6512:   type = TREE_TYPE (TREE_OPERAND (exp, 0));
        !          6513:   
        !          6514:   /* Push the quantum.  */
        !          6515:   bc_expand_expr (TREE_OPERAND (exp, 1));
        !          6516:   
        !          6517:   /* Convert it to the lvalue's type.  */
        !          6518:   bc_expand_conversion (TREE_TYPE (TREE_OPERAND (exp, 1)), type);
        !          6519:   
        !          6520:   /* Push the address of the lvalue */
        !          6521:   bc_expand_expr (build1 (ADDR_EXPR, TYPE_POINTER_TO (type), TREE_OPERAND (exp, 0)));
        !          6522:   
        !          6523:   /* Perform actual increment */
        !          6524:   bc_expand_increment (incroptab, type);
        !          6525:   return;
        !          6526: }
        !          6527: 
        !          6528: /* Return the alignment in bits of EXP, a pointer valued expression.
        !          6529:    But don't return more than MAX_ALIGN no matter what.
        !          6530:    The alignment returned is, by default, the alignment of the thing that
        !          6531:    EXP points to (if it is not a POINTER_TYPE, 0 is returned).
        !          6532: 
        !          6533:    Otherwise, look at the expression to see if we can do better, i.e., if the
        !          6534:    expression is actually pointing at an object whose alignment is tighter.  */
        !          6535: 
        !          6536: static int
        !          6537: get_pointer_alignment (exp, max_align)
        !          6538:      tree exp;
        !          6539:      unsigned max_align;
        !          6540: {
        !          6541:   unsigned align, inner;
        !          6542: 
        !          6543:   if (TREE_CODE (TREE_TYPE (exp)) != POINTER_TYPE)
        !          6544:     return 0;
        !          6545: 
        !          6546:   align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
        !          6547:   align = MIN (align, max_align);
        !          6548: 
        !          6549:   while (1)
        !          6550:     {
        !          6551:       switch (TREE_CODE (exp))
        !          6552:        {
        !          6553:        case NOP_EXPR:
        !          6554:        case CONVERT_EXPR:
        !          6555:        case NON_LVALUE_EXPR:
        !          6556:          exp = TREE_OPERAND (exp, 0);
        !          6557:          if (TREE_CODE (TREE_TYPE (exp)) != POINTER_TYPE)
        !          6558:            return align;
        !          6559:          inner = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
        !          6560:          inner = MIN (inner, max_align);
        !          6561:          align = MAX (align, inner);
        !          6562:          break;
        !          6563: 
        !          6564:        case PLUS_EXPR:
        !          6565:          /* If sum of pointer + int, restrict our maximum alignment to that
        !          6566:             imposed by the integer.  If not, we can't do any better than
        !          6567:             ALIGN.  */
        !          6568:          if (TREE_CODE (TREE_OPERAND (exp, 1)) != INTEGER_CST)
        !          6569:            return align;
        !          6570: 
        !          6571:          while (((TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)) * BITS_PER_UNIT)
        !          6572:                  & (max_align - 1))
        !          6573:                 != 0)
        !          6574:            max_align >>= 1;
        !          6575: 
        !          6576:          exp = TREE_OPERAND (exp, 0);
        !          6577:          break;
        !          6578: 
        !          6579:        case ADDR_EXPR:
        !          6580:          /* See what we are pointing at and look at its alignment.  */
        !          6581:          exp = TREE_OPERAND (exp, 0);
        !          6582:          if (TREE_CODE (exp) == FUNCTION_DECL)
        !          6583:            align = MAX (align, FUNCTION_BOUNDARY);
        !          6584:          else if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd')
        !          6585:            align = MAX (align, DECL_ALIGN (exp));
        !          6586: #ifdef CONSTANT_ALIGNMENT
        !          6587:          else if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c')
        !          6588:            align = CONSTANT_ALIGNMENT (exp, align);
        !          6589: #endif
        !          6590:          return MIN (align, max_align);
        !          6591: 
        !          6592:        default:
        !          6593:          return align;
        !          6594:        }
        !          6595:     }
        !          6596: }
        !          6597: 
        !          6598: /* Return the tree node and offset if a given argument corresponds to
        !          6599:    a string constant.  */
        !          6600: 
        !          6601: static tree
        !          6602: string_constant (arg, ptr_offset)
        !          6603:      tree arg;
        !          6604:      tree *ptr_offset;
        !          6605: {
        !          6606:   STRIP_NOPS (arg);
        !          6607: 
        !          6608:   if (TREE_CODE (arg) == ADDR_EXPR
        !          6609:       && TREE_CODE (TREE_OPERAND (arg, 0)) == STRING_CST)
        !          6610:     {
        !          6611:       *ptr_offset = integer_zero_node;
        !          6612:       return TREE_OPERAND (arg, 0);
        !          6613:     }
        !          6614:   else if (TREE_CODE (arg) == PLUS_EXPR)
        !          6615:     {
        !          6616:       tree arg0 = TREE_OPERAND (arg, 0);
        !          6617:       tree arg1 = TREE_OPERAND (arg, 1);
        !          6618: 
        !          6619:       STRIP_NOPS (arg0);
        !          6620:       STRIP_NOPS (arg1);
        !          6621: 
        !          6622:       if (TREE_CODE (arg0) == ADDR_EXPR
        !          6623:          && TREE_CODE (TREE_OPERAND (arg0, 0)) == STRING_CST)
        !          6624:        {
        !          6625:          *ptr_offset = arg1;
        !          6626:          return TREE_OPERAND (arg0, 0);
        !          6627:        }
        !          6628:       else if (TREE_CODE (arg1) == ADDR_EXPR
        !          6629:               && TREE_CODE (TREE_OPERAND (arg1, 0)) == STRING_CST)
        !          6630:        {
        !          6631:          *ptr_offset = arg0;
        !          6632:          return TREE_OPERAND (arg1, 0);
        !          6633:        }
        !          6634:     }
        !          6635: 
        !          6636:   return 0;
        !          6637: }
        !          6638: 
        !          6639: /* Compute the length of a C string.  TREE_STRING_LENGTH is not the right
        !          6640:    way, because it could contain a zero byte in the middle.
        !          6641:    TREE_STRING_LENGTH is the size of the character array, not the string.
        !          6642: 
        !          6643:    Unfortunately, string_constant can't access the values of const char
        !          6644:    arrays with initializers, so neither can we do so here.  */
        !          6645: 
        !          6646: static tree
        !          6647: c_strlen (src)
        !          6648:      tree src;
        !          6649: {
        !          6650:   tree offset_node;
        !          6651:   int offset, max;
        !          6652:   char *ptr;
        !          6653: 
        !          6654:   src = string_constant (src, &offset_node);
        !          6655:   if (src == 0)
        !          6656:     return 0;
        !          6657:   max = TREE_STRING_LENGTH (src);
        !          6658:   ptr = TREE_STRING_POINTER (src);
        !          6659:   if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
        !          6660:     {
        !          6661:       /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
        !          6662:         compute the offset to the following null if we don't know where to
        !          6663:         start searching for it.  */
        !          6664:       int i;
        !          6665:       for (i = 0; i < max; i++)
        !          6666:        if (ptr[i] == 0)
        !          6667:          return 0;
        !          6668:       /* We don't know the starting offset, but we do know that the string
        !          6669:         has no internal zero bytes.  We can assume that the offset falls
        !          6670:         within the bounds of the string; otherwise, the programmer deserves
        !          6671:         what he gets.  Subtract the offset from the length of the string,
        !          6672:         and return that.  */
        !          6673:       /* This would perhaps not be valid if we were dealing with named
        !          6674:          arrays in addition to literal string constants.  */
        !          6675:       return size_binop (MINUS_EXPR, size_int (max), offset_node);
        !          6676:     }
        !          6677: 
        !          6678:   /* We have a known offset into the string.  Start searching there for
        !          6679:      a null character.  */
        !          6680:   if (offset_node == 0)
        !          6681:     offset = 0;
        !          6682:   else
        !          6683:     {
        !          6684:       /* Did we get a long long offset?  If so, punt.  */
        !          6685:       if (TREE_INT_CST_HIGH (offset_node) != 0)
        !          6686:        return 0;
        !          6687:       offset = TREE_INT_CST_LOW (offset_node);
        !          6688:     }
        !          6689:   /* If the offset is known to be out of bounds, warn, and call strlen at
        !          6690:      runtime.  */
        !          6691:   if (offset < 0 || offset > max)
        !          6692:     {
        !          6693:       warning ("offset outside bounds of constant string");
        !          6694:       return 0;
        !          6695:     }
        !          6696:   /* Use strlen to search for the first zero byte.  Since any strings
        !          6697:      constructed with build_string will have nulls appended, we win even
        !          6698:      if we get handed something like (char[4])"abcd".
        !          6699: 
        !          6700:      Since OFFSET is our starting index into the string, no further
        !          6701:      calculation is needed.  */
        !          6702:   return size_int (strlen (ptr + offset));
        !          6703: }
        !          6704: 
        !          6705: /* Expand an expression EXP that calls a built-in function,
        !          6706:    with result going to TARGET if that's convenient
        !          6707:    (and in mode MODE if that's convenient).
        !          6708:    SUBTARGET may be used as the target for computing one of EXP's operands.
        !          6709:    IGNORE is nonzero if the value is to be ignored.  */
        !          6710: 
        !          6711: static rtx
        !          6712: expand_builtin (exp, target, subtarget, mode, ignore)
        !          6713:      tree exp;
        !          6714:      rtx target;
        !          6715:      rtx subtarget;
        !          6716:      enum machine_mode mode;
        !          6717:      int ignore;
        !          6718: {
        !          6719:   tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
        !          6720:   tree arglist = TREE_OPERAND (exp, 1);
        !          6721:   rtx op0;
        !          6722:   rtx lab1, insns;
        !          6723:   enum machine_mode value_mode = TYPE_MODE (TREE_TYPE (exp));
        !          6724:   optab builtin_optab;
        !          6725: 
        !          6726:   switch (DECL_FUNCTION_CODE (fndecl))
        !          6727:     {
        !          6728:     case BUILT_IN_ABS:
        !          6729:     case BUILT_IN_LABS:
        !          6730:     case BUILT_IN_FABS:
        !          6731:       /* build_function_call changes these into ABS_EXPR.  */
        !          6732:       abort ();
        !          6733: 
        !          6734:     case BUILT_IN_SIN:
        !          6735:     case BUILT_IN_COS:
        !          6736:     case BUILT_IN_FSQRT:
        !          6737:       /* If not optimizing, call the library function.  */
        !          6738:       if (! optimize)
        !          6739:        break;
        !          6740: 
        !          6741:       if (arglist == 0
        !          6742:          /* Arg could be wrong type if user redeclared this fcn wrong.  */
        !          6743:          || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != REAL_TYPE)
        !          6744:        break;
        !          6745: 
        !          6746:       /* Stabilize and compute the argument.  */
        !          6747:       if (TREE_CODE (TREE_VALUE (arglist)) != VAR_DECL
        !          6748:          && TREE_CODE (TREE_VALUE (arglist)) != PARM_DECL)
        !          6749:        {
        !          6750:          exp = copy_node (exp);
        !          6751:          arglist = copy_node (arglist);
        !          6752:          TREE_OPERAND (exp, 1) = arglist;
        !          6753:          TREE_VALUE (arglist) = save_expr (TREE_VALUE (arglist));
        !          6754:        }
        !          6755:       op0 = expand_expr (TREE_VALUE (arglist), subtarget, VOIDmode, 0);
        !          6756: 
        !          6757:       /* Make a suitable register to place result in.  */
        !          6758:       target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
        !          6759: 
        !          6760:       emit_queue ();
        !          6761:       start_sequence ();
        !          6762: 
        !          6763:       switch (DECL_FUNCTION_CODE (fndecl))
        !          6764:        {
        !          6765:        case BUILT_IN_SIN:
        !          6766:          builtin_optab = sin_optab; break;
        !          6767:        case BUILT_IN_COS:
        !          6768:          builtin_optab = cos_optab; break;
        !          6769:        case BUILT_IN_FSQRT:
        !          6770:          builtin_optab = sqrt_optab; break;
        !          6771:        default:
        !          6772:          abort ();
        !          6773:        }
        !          6774: 
        !          6775:       /* Compute into TARGET.
        !          6776:         Set TARGET to wherever the result comes back.  */
        !          6777:       target = expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist))),
        !          6778:                            builtin_optab, op0, target, 0);
        !          6779: 
        !          6780:       /* If we were unable to expand via the builtin, stop the
        !          6781:         sequence (without outputting the insns) and break, causing
        !          6782:         a call the the library function.  */
        !          6783:       if (target == 0)
        !          6784:        {
        !          6785:          end_sequence ();
        !          6786:          break;
        !          6787:         }
        !          6788: 
        !          6789:       /* Check the results by default.  But if flag_fast_math is turned on,
        !          6790:         then assume sqrt will always be called with valid arguments.  */
        !          6791: 
        !          6792:       if (! flag_fast_math)
        !          6793:        {
        !          6794:          /* Don't define the builtin FP instructions
        !          6795:             if your machine is not IEEE.  */
        !          6796:          if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
        !          6797:            abort ();
        !          6798: 
        !          6799:          lab1 = gen_label_rtx ();
        !          6800: 
        !          6801:          /* Test the result; if it is NaN, set errno=EDOM because
        !          6802:             the argument was not in the domain.  */
        !          6803:          emit_cmp_insn (target, target, EQ, 0, GET_MODE (target), 0, 0);
        !          6804:          emit_jump_insn (gen_beq (lab1));
        !          6805: 
        !          6806: #if TARGET_EDOM
        !          6807:          {
        !          6808: #ifdef GEN_ERRNO_RTX
        !          6809:            rtx errno_rtx = GEN_ERRNO_RTX;
        !          6810: #else
        !          6811:            rtx errno_rtx
        !          6812:              = gen_rtx (MEM, word_mode, gen_rtx (SYMBOL_REF, Pmode, "*errno"));
        !          6813: #endif
        !          6814: 
        !          6815:            emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
        !          6816:          }
        !          6817: #else
        !          6818:          /* We can't set errno=EDOM directly; let the library call do it.
        !          6819:             Pop the arguments right away in case the call gets deleted. */
        !          6820:          NO_DEFER_POP;
        !          6821:          expand_call (exp, target, 0);
        !          6822:          OK_DEFER_POP;
        !          6823: #endif
        !          6824: 
        !          6825:          emit_label (lab1);
        !          6826:        }
        !          6827: 
        !          6828:       /* Output the entire sequence. */
        !          6829:       insns = get_insns ();
        !          6830:       end_sequence ();
        !          6831:       emit_insns (insns);
        !          6832:  
        !          6833:       return target;
        !          6834: 
        !          6835:       /* __builtin_apply_args returns block of memory allocated on
        !          6836:         the stack into which is stored the arg pointer, structure
        !          6837:         value address, static chain, and all the registers that might
        !          6838:         possibly be used in performing a function call.  The code is
        !          6839:         moved to the start of the function so the incoming values are
        !          6840:         saved.  */
        !          6841:     case BUILT_IN_APPLY_ARGS:
        !          6842:       /* Don't do __builtin_apply_args more than once in a function.
        !          6843:         Save the result of the first call and reuse it.  */
        !          6844:       if (apply_args_value != 0)
        !          6845:        return apply_args_value;
        !          6846:       {
        !          6847:        /* When this function is called, it means that registers must be
        !          6848:           saved on entry to this function.  So we migrate the
        !          6849:           call to the first insn of this function.  */
        !          6850:        rtx temp;
        !          6851:        rtx seq;
        !          6852: 
        !          6853:        start_sequence ();
        !          6854:        temp = expand_builtin_apply_args ();
        !          6855:        seq = get_insns ();
        !          6856:        end_sequence ();
        !          6857: 
        !          6858:        apply_args_value = temp;
        !          6859: 
        !          6860:        /* Put the sequence after the NOTE that starts the function.
        !          6861:           If this is inside a SEQUENCE, make the outer-level insn
        !          6862:           chain current, so the code is placed at the start of the
        !          6863:           function.  */
        !          6864:        push_topmost_sequence ();
        !          6865:        emit_insns_before (seq, NEXT_INSN (get_insns ()));
        !          6866:        pop_topmost_sequence ();
        !          6867:        return temp;
        !          6868:       }
        !          6869: 
        !          6870:       /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
        !          6871:         FUNCTION with a copy of the parameters described by
        !          6872:         ARGUMENTS, and ARGSIZE.  It returns a block of memory
        !          6873:         allocated on the stack into which is stored all the registers
        !          6874:         that might possibly be used for returning the result of a
        !          6875:         function.  ARGUMENTS is the value returned by
        !          6876:         __builtin_apply_args.  ARGSIZE is the number of bytes of
        !          6877:         arguments that must be copied.  ??? How should this value be
        !          6878:         computed?  We'll also need a safe worst case value for varargs
        !          6879:         functions.  */
        !          6880:     case BUILT_IN_APPLY:
        !          6881:       if (arglist == 0
        !          6882:          /* Arg could be non-pointer if user redeclared this fcn wrong.  */
        !          6883:          || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
        !          6884:          || TREE_CHAIN (arglist) == 0
        !          6885:          || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE
        !          6886:          || TREE_CHAIN (TREE_CHAIN (arglist)) == 0
        !          6887:          || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))))) != INTEGER_TYPE)
        !          6888:        return const0_rtx;
        !          6889:       else
        !          6890:        {
        !          6891:          int i;
        !          6892:          tree t;
        !          6893:          rtx ops[3];
        !          6894: 
        !          6895:          for (t = arglist, i = 0; t; t = TREE_CHAIN (t), i++)
        !          6896:            ops[i] = expand_expr (TREE_VALUE (t), NULL_RTX, VOIDmode, 0);
        !          6897: 
        !          6898:          return expand_builtin_apply (ops[0], ops[1], ops[2]);
        !          6899:        }
        !          6900: 
        !          6901:       /* __builtin_return (RESULT) causes the function to return the
        !          6902:         value described by RESULT.  RESULT is address of the block of
        !          6903:         memory returned by __builtin_apply.  */
        !          6904:     case BUILT_IN_RETURN:
        !          6905:       if (arglist
        !          6906:          /* Arg could be non-pointer if user redeclared this fcn wrong.  */
        !          6907:          && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE)
        !          6908:        expand_builtin_return (expand_expr (TREE_VALUE (arglist),
        !          6909:                                            NULL_RTX, VOIDmode, 0));
        !          6910:       return const0_rtx;
        !          6911: 
        !          6912:     case BUILT_IN_SAVEREGS:
        !          6913:       /* Don't do __builtin_saveregs more than once in a function.
        !          6914:         Save the result of the first call and reuse it.  */
        !          6915:       if (saveregs_value != 0)
        !          6916:        return saveregs_value;
        !          6917:       {
        !          6918:        /* When this function is called, it means that registers must be
        !          6919:           saved on entry to this function.  So we migrate the
        !          6920:           call to the first insn of this function.  */
        !          6921:        rtx temp;
        !          6922:        rtx seq;
        !          6923:        rtx valreg, saved_valreg;
        !          6924: 
        !          6925:        /* Now really call the function.  `expand_call' does not call
        !          6926:           expand_builtin, so there is no danger of infinite recursion here.  */
        !          6927:        start_sequence ();
        !          6928: 
        !          6929: #ifdef EXPAND_BUILTIN_SAVEREGS
        !          6930:        /* Do whatever the machine needs done in this case.  */
        !          6931:        temp = EXPAND_BUILTIN_SAVEREGS (arglist);
        !          6932: #else
        !          6933:        /* The register where the function returns its value
        !          6934:           is likely to have something else in it, such as an argument.
        !          6935:           So preserve that register around the call.  */
        !          6936:        if (value_mode != VOIDmode)
        !          6937:          {
        !          6938:            valreg = hard_libcall_value (value_mode);
        !          6939:            saved_valreg = gen_reg_rtx (value_mode);
        !          6940:            emit_move_insn (saved_valreg, valreg);
        !          6941:          }
        !          6942: 
        !          6943:        /* Generate the call, putting the value in a pseudo.  */
        !          6944:        temp = expand_call (exp, target, ignore);
        !          6945: 
        !          6946:        if (value_mode != VOIDmode)
        !          6947:          emit_move_insn (valreg, saved_valreg);
        !          6948: #endif
        !          6949: 
        !          6950:        seq = get_insns ();
        !          6951:        end_sequence ();
        !          6952: 
        !          6953:        saveregs_value = temp;
        !          6954: 
        !          6955:        /* Put the sequence after the NOTE that starts the function.
        !          6956:           If this is inside a SEQUENCE, make the outer-level insn
        !          6957:           chain current, so the code is placed at the start of the
        !          6958:           function.  */
        !          6959:        push_topmost_sequence ();
        !          6960:        emit_insns_before (seq, NEXT_INSN (get_insns ()));
        !          6961:        pop_topmost_sequence ();
        !          6962:        return temp;
        !          6963:       }
        !          6964: 
        !          6965:       /* __builtin_args_info (N) returns word N of the arg space info
        !          6966:         for the current function.  The number and meanings of words
        !          6967:         is controlled by the definition of CUMULATIVE_ARGS.  */
        !          6968:     case BUILT_IN_ARGS_INFO:
        !          6969:       {
        !          6970:        int nwords = sizeof (CUMULATIVE_ARGS) / sizeof (int);
        !          6971:        int i;
        !          6972:        int *word_ptr = (int *) &current_function_args_info;
        !          6973:        tree type, elts, result;
        !          6974: 
        !          6975:        if (sizeof (CUMULATIVE_ARGS) % sizeof (int) != 0)
        !          6976:          fatal ("CUMULATIVE_ARGS type defined badly; see %s, line %d",
        !          6977:                 __FILE__, __LINE__);
        !          6978: 
        !          6979:        if (arglist != 0)
        !          6980:          {
        !          6981:            tree arg = TREE_VALUE (arglist);
        !          6982:            if (TREE_CODE (arg) != INTEGER_CST)
        !          6983:              error ("argument of `__builtin_args_info' must be constant");
        !          6984:            else
        !          6985:              {
        !          6986:                int wordnum = TREE_INT_CST_LOW (arg);
        !          6987: 
        !          6988:                if (wordnum < 0 || wordnum >= nwords || TREE_INT_CST_HIGH (arg))
        !          6989:                  error ("argument of `__builtin_args_info' out of range");
        !          6990:                else
        !          6991:                  return GEN_INT (word_ptr[wordnum]);
        !          6992:              }
        !          6993:          }
        !          6994:        else
        !          6995:          error ("missing argument in `__builtin_args_info'");
        !          6996: 
        !          6997:        return const0_rtx;
        !          6998: 
        !          6999: #if 0
        !          7000:        for (i = 0; i < nwords; i++)
        !          7001:          elts = tree_cons (NULL_TREE, build_int_2 (word_ptr[i], 0));
        !          7002: 
        !          7003:        type = build_array_type (integer_type_node,
        !          7004:                                 build_index_type (build_int_2 (nwords, 0)));
        !          7005:        result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (elts));
        !          7006:        TREE_CONSTANT (result) = 1;
        !          7007:        TREE_STATIC (result) = 1;
        !          7008:        result = build (INDIRECT_REF, build_pointer_type (type), result);
        !          7009:        TREE_CONSTANT (result) = 1;
        !          7010:        return expand_expr (result, NULL_RTX, VOIDmode, 0);
        !          7011: #endif
        !          7012:       }
        !          7013: 
        !          7014:       /* Return the address of the first anonymous stack arg.  */
        !          7015:     case BUILT_IN_NEXT_ARG:
        !          7016:       {
        !          7017:        tree fntype = TREE_TYPE (current_function_decl);
        !          7018:        if (!(TYPE_ARG_TYPES (fntype) != 0
        !          7019:              && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
        !          7020:                  != void_type_node)))
        !          7021:          {
        !          7022:            error ("`va_start' used in function with fixed args");
        !          7023:            return const0_rtx;
        !          7024:          }
        !          7025:       }
        !          7026: 
        !          7027:       return expand_binop (Pmode, add_optab,
        !          7028:                           current_function_internal_arg_pointer,
        !          7029:                           current_function_arg_offset_rtx,
        !          7030:                           NULL_RTX, 0, OPTAB_LIB_WIDEN);
        !          7031: 
        !          7032:     case BUILT_IN_CLASSIFY_TYPE:
        !          7033:       if (arglist != 0)
        !          7034:        {
        !          7035:          tree type = TREE_TYPE (TREE_VALUE (arglist));
        !          7036:          enum tree_code code = TREE_CODE (type);
        !          7037:          if (code == VOID_TYPE)
        !          7038:            return GEN_INT (void_type_class);
        !          7039:          if (code == INTEGER_TYPE)
        !          7040:            return GEN_INT (integer_type_class);
        !          7041:          if (code == CHAR_TYPE)
        !          7042:            return GEN_INT (char_type_class);
        !          7043:          if (code == ENUMERAL_TYPE)
        !          7044:            return GEN_INT (enumeral_type_class);
        !          7045:          if (code == BOOLEAN_TYPE)
        !          7046:            return GEN_INT (boolean_type_class);
        !          7047:          if (code == POINTER_TYPE)
        !          7048:            return GEN_INT (pointer_type_class);
        !          7049:          if (code == REFERENCE_TYPE)
        !          7050:            return GEN_INT (reference_type_class);
        !          7051:          if (code == OFFSET_TYPE)
        !          7052:            return GEN_INT (offset_type_class);
        !          7053:          if (code == REAL_TYPE)
        !          7054:            return GEN_INT (real_type_class);
        !          7055:          if (code == COMPLEX_TYPE)
        !          7056:            return GEN_INT (complex_type_class);
        !          7057:          if (code == FUNCTION_TYPE)
        !          7058:            return GEN_INT (function_type_class);
        !          7059:          if (code == METHOD_TYPE)
        !          7060:            return GEN_INT (method_type_class);
        !          7061:          if (code == RECORD_TYPE)
        !          7062:            return GEN_INT (record_type_class);
        !          7063:          if (code == UNION_TYPE || code == QUAL_UNION_TYPE)
        !          7064:            return GEN_INT (union_type_class);
        !          7065:          if (code == ARRAY_TYPE)
        !          7066:            return GEN_INT (array_type_class);
        !          7067:          if (code == STRING_TYPE)
        !          7068:            return GEN_INT (string_type_class);
        !          7069:          if (code == SET_TYPE)
        !          7070:            return GEN_INT (set_type_class);
        !          7071:          if (code == FILE_TYPE)
        !          7072:            return GEN_INT (file_type_class);
        !          7073:          if (code == LANG_TYPE)
        !          7074:            return GEN_INT (lang_type_class);
        !          7075:        }
        !          7076:       return GEN_INT (no_type_class);
        !          7077: 
        !          7078:     case BUILT_IN_CONSTANT_P:
        !          7079:       if (arglist == 0)
        !          7080:        return const0_rtx;
        !          7081:       else
        !          7082:        return (TREE_CODE_CLASS (TREE_CODE (TREE_VALUE (arglist))) == 'c'
        !          7083:                ? const1_rtx : const0_rtx);
        !          7084: 
        !          7085:     case BUILT_IN_FRAME_ADDRESS:
        !          7086:       /* The argument must be a nonnegative integer constant.
        !          7087:         It counts the number of frames to scan up the stack.
        !          7088:         The value is the address of that frame.  */
        !          7089:     case BUILT_IN_RETURN_ADDRESS:
        !          7090:       /* The argument must be a nonnegative integer constant.
        !          7091:         It counts the number of frames to scan up the stack.
        !          7092:         The value is the return address saved in that frame.  */
        !          7093:       if (arglist == 0)
        !          7094:        /* Warning about missing arg was already issued.  */
        !          7095:        return const0_rtx;
        !          7096:       else if (TREE_CODE (TREE_VALUE (arglist)) != INTEGER_CST)
        !          7097:        {
        !          7098:          error ("invalid arg to `__builtin_return_address'");
        !          7099:          return const0_rtx;
        !          7100:        }
        !          7101:       else if (tree_int_cst_lt (TREE_VALUE (arglist), integer_zero_node))
        !          7102:        {
        !          7103:          error ("invalid arg to `__builtin_return_address'");
        !          7104:          return const0_rtx;
        !          7105:        }
        !          7106:       else
        !          7107:        {
        !          7108:          int count = TREE_INT_CST_LOW (TREE_VALUE (arglist)); 
        !          7109:          rtx tem = frame_pointer_rtx;
        !          7110:          int i;
        !          7111: 
        !          7112:          /* Some machines need special handling before we can access arbitrary
        !          7113:             frames.  For example, on the sparc, we must first flush all
        !          7114:             register windows to the stack.  */
        !          7115: #ifdef SETUP_FRAME_ADDRESSES
        !          7116:          SETUP_FRAME_ADDRESSES ();
        !          7117: #endif
        !          7118: 
        !          7119:          /* On the sparc, the return address is not in the frame, it is
        !          7120:             in a register.  There is no way to access it off of the current
        !          7121:             frame pointer, but it can be accessed off the previous frame
        !          7122:             pointer by reading the value from the register window save
        !          7123:             area.  */
        !          7124: #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
        !          7125:          if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_RETURN_ADDRESS)
        !          7126:            count--;
        !          7127: #endif
        !          7128: 
        !          7129:          /* Scan back COUNT frames to the specified frame.  */
        !          7130:          for (i = 0; i < count; i++)
        !          7131:            {
        !          7132:              /* Assume the dynamic chain pointer is in the word that
        !          7133:                 the frame address points to, unless otherwise specified.  */
        !          7134: #ifdef DYNAMIC_CHAIN_ADDRESS
        !          7135:              tem = DYNAMIC_CHAIN_ADDRESS (tem);
        !          7136: #endif
        !          7137:              tem = memory_address (Pmode, tem);
        !          7138:              tem = copy_to_reg (gen_rtx (MEM, Pmode, tem));
        !          7139:            }
        !          7140: 
        !          7141:          /* For __builtin_frame_address, return what we've got.  */
        !          7142:          if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
        !          7143:            return tem;
        !          7144: 
        !          7145:          /* For __builtin_return_address,
        !          7146:             Get the return address from that frame.  */
        !          7147: #ifdef RETURN_ADDR_RTX
        !          7148:          return RETURN_ADDR_RTX (count, tem);
        !          7149: #else
        !          7150:          tem = memory_address (Pmode,
        !          7151:                                plus_constant (tem, GET_MODE_SIZE (Pmode)));
        !          7152:          return copy_to_reg (gen_rtx (MEM, Pmode, tem));
        !          7153: #endif
        !          7154:        }
        !          7155: 
        !          7156:     case BUILT_IN_ALLOCA:
        !          7157:       if (arglist == 0
        !          7158:          /* Arg could be non-integer if user redeclared this fcn wrong.  */
        !          7159:          || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE)
        !          7160:        break;
        !          7161:       current_function_calls_alloca = 1;
        !          7162:       /* Compute the argument.  */
        !          7163:       op0 = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
        !          7164: 
        !          7165:       /* Allocate the desired space.  */
        !          7166:       target = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
        !          7167: 
        !          7168:       /* Record the new stack level for nonlocal gotos.  */
        !          7169:       if (nonlocal_goto_handler_slot != 0)
        !          7170:        emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
        !          7171:       return target;
        !          7172: 
        !          7173:     case BUILT_IN_FFS:
        !          7174:       /* If not optimizing, call the library function.  */
        !          7175:       if (!optimize)
        !          7176:        break;
        !          7177: 
        !          7178:       if (arglist == 0
        !          7179:          /* Arg could be non-integer if user redeclared this fcn wrong.  */
        !          7180:          || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE)
        !          7181:        break;
        !          7182: 
        !          7183:       /* Compute the argument.  */
        !          7184:       op0 = expand_expr (TREE_VALUE (arglist), subtarget, VOIDmode, 0);
        !          7185:       /* Compute ffs, into TARGET if possible.
        !          7186:         Set TARGET to wherever the result comes back.  */
        !          7187:       target = expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist))),
        !          7188:                            ffs_optab, op0, target, 1);
        !          7189:       if (target == 0)
        !          7190:        abort ();
        !          7191:       return target;
        !          7192: 
        !          7193:     case BUILT_IN_STRLEN:
        !          7194:       /* If not optimizing, call the library function.  */
        !          7195:       if (!optimize)
        !          7196:        break;
        !          7197: 
        !          7198:       if (arglist == 0
        !          7199:          /* Arg could be non-pointer if user redeclared this fcn wrong.  */
        !          7200:          || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
        !          7201:        break;
        !          7202:       else
        !          7203:        {
        !          7204:          tree src = TREE_VALUE (arglist);
        !          7205:          tree len = c_strlen (src);
        !          7206: 
        !          7207:          int align
        !          7208:            = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
        !          7209: 
        !          7210:          rtx result, src_rtx, char_rtx;
        !          7211:          enum machine_mode insn_mode = value_mode, char_mode;
        !          7212:          enum insn_code icode;
        !          7213: 
        !          7214:          /* If the length is known, just return it. */
        !          7215:          if (len != 0)
        !          7216:            return expand_expr (len, target, mode, 0);
        !          7217: 
        !          7218:          /* If SRC is not a pointer type, don't do this operation inline. */
        !          7219:          if (align == 0)
        !          7220:            break;
        !          7221: 
        !          7222:          /* Call a function if we can't compute strlen in the right mode. */
        !          7223: 
        !          7224:          while (insn_mode != VOIDmode)
        !          7225:            {
        !          7226:              icode = strlen_optab->handlers[(int) insn_mode].insn_code;
        !          7227:              if (icode != CODE_FOR_nothing)
        !          7228:                break;
        !          7229: 
        !          7230:              insn_mode = GET_MODE_WIDER_MODE (insn_mode);
        !          7231:            }
        !          7232:          if (insn_mode == VOIDmode)
        !          7233:            break;
        !          7234: 
        !          7235:          /* Make a place to write the result of the instruction.  */
        !          7236:          result = target;
        !          7237:          if (! (result != 0
        !          7238:                 && GET_CODE (result) == REG
        !          7239:                 && GET_MODE (result) == insn_mode
        !          7240:                 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
        !          7241:            result = gen_reg_rtx (insn_mode);
        !          7242: 
        !          7243:          /* Make sure the operands are acceptable to the predicates.  */
        !          7244: 
        !          7245:          if (! (*insn_operand_predicate[(int)icode][0]) (result, insn_mode))
        !          7246:            result = gen_reg_rtx (insn_mode);
        !          7247: 
        !          7248:          src_rtx = memory_address (BLKmode,
        !          7249:                                    expand_expr (src, NULL_RTX, Pmode,
        !          7250:                                                 EXPAND_NORMAL));
        !          7251:          if (! (*insn_operand_predicate[(int)icode][1]) (src_rtx, Pmode))
        !          7252:            src_rtx = copy_to_mode_reg (Pmode, src_rtx);
        !          7253: 
        !          7254:          char_rtx = const0_rtx;
        !          7255:          char_mode = insn_operand_mode[(int)icode][2];
        !          7256:          if (! (*insn_operand_predicate[(int)icode][2]) (char_rtx, char_mode))
        !          7257:            char_rtx = copy_to_mode_reg (char_mode, char_rtx);
        !          7258: 
        !          7259:          emit_insn (GEN_FCN (icode) (result,
        !          7260:                                      gen_rtx (MEM, BLKmode, src_rtx),
        !          7261:                                      char_rtx, GEN_INT (align)));
        !          7262: 
        !          7263:          /* Return the value in the proper mode for this function.  */
        !          7264:          if (GET_MODE (result) == value_mode)
        !          7265:            return result;
        !          7266:          else if (target != 0)
        !          7267:            {
        !          7268:              convert_move (target, result, 0);
        !          7269:              return target;
        !          7270:            }
        !          7271:          else
        !          7272:            return convert_to_mode (value_mode, result, 0);
        !          7273:        }
        !          7274: 
        !          7275:     case BUILT_IN_STRCPY:
        !          7276:       /* If not optimizing, call the library function.  */
        !          7277:       if (!optimize)
        !          7278:        break;
        !          7279: 
        !          7280:       if (arglist == 0
        !          7281:          /* Arg could be non-pointer if user redeclared this fcn wrong.  */
        !          7282:          || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
        !          7283:          || TREE_CHAIN (arglist) == 0
        !          7284:          || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE)
        !          7285:        break;
        !          7286:       else
        !          7287:        {
        !          7288:          tree len = c_strlen (TREE_VALUE (TREE_CHAIN (arglist)));
        !          7289: 
        !          7290:          if (len == 0)
        !          7291:            break;
        !          7292: 
        !          7293:          len = size_binop (PLUS_EXPR, len, integer_one_node);
        !          7294: 
        !          7295:          chainon (arglist, build_tree_list (NULL_TREE, len));
        !          7296:        }
        !          7297: 
        !          7298:       /* Drops in.  */
        !          7299:     case BUILT_IN_MEMCPY:
        !          7300:       /* If not optimizing, call the library function.  */
        !          7301:       if (!optimize)
        !          7302:        break;
        !          7303: 
        !          7304:       if (arglist == 0
        !          7305:          /* Arg could be non-pointer if user redeclared this fcn wrong.  */
        !          7306:          || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
        !          7307:          || TREE_CHAIN (arglist) == 0
        !          7308:          || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE
        !          7309:          || TREE_CHAIN (TREE_CHAIN (arglist)) == 0
        !          7310:          || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))))) != INTEGER_TYPE)
        !          7311:        break;
        !          7312:       else
        !          7313:        {
        !          7314:          tree dest = TREE_VALUE (arglist);
        !          7315:          tree src = TREE_VALUE (TREE_CHAIN (arglist));
        !          7316:          tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
        !          7317: 
        !          7318:          int src_align
        !          7319:            = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
        !          7320:          int dest_align
        !          7321:            = get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
        !          7322:          rtx dest_rtx, dest_mem, src_mem;
        !          7323: 
        !          7324:          /* If either SRC or DEST is not a pointer type, don't do
        !          7325:             this operation in-line.  */
        !          7326:          if (src_align == 0 || dest_align == 0)
        !          7327:            {
        !          7328:              if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRCPY)
        !          7329:                TREE_CHAIN (TREE_CHAIN (arglist)) = 0;
        !          7330:              break;
        !          7331:            }
        !          7332: 
        !          7333:          dest_rtx = expand_expr (dest, NULL_RTX, Pmode, EXPAND_NORMAL);
        !          7334:          dest_mem = gen_rtx (MEM, BLKmode,
        !          7335:                              memory_address (BLKmode, dest_rtx));
        !          7336:          src_mem = gen_rtx (MEM, BLKmode,
        !          7337:                             memory_address (BLKmode,
        !          7338:                                             expand_expr (src, NULL_RTX,
        !          7339:                                                          Pmode,
        !          7340:                                                          EXPAND_NORMAL)));
        !          7341: 
        !          7342:          /* Copy word part most expediently.  */
        !          7343:          emit_block_move (dest_mem, src_mem,
        !          7344:                           expand_expr (len, NULL_RTX, VOIDmode, 0),
        !          7345:                           MIN (src_align, dest_align));
        !          7346:          return dest_rtx;
        !          7347:        }
        !          7348: 
        !          7349: /* These comparison functions need an instruction that returns an actual
        !          7350:    index.  An ordinary compare that just sets the condition codes
        !          7351:    is not enough.  */
        !          7352: #ifdef HAVE_cmpstrsi
        !          7353:     case BUILT_IN_STRCMP:
        !          7354:       /* If not optimizing, call the library function.  */
        !          7355:       if (!optimize)
        !          7356:        break;
        !          7357: 
        !          7358:       if (arglist == 0
        !          7359:          /* Arg could be non-pointer if user redeclared this fcn wrong.  */
        !          7360:          || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
        !          7361:          || TREE_CHAIN (arglist) == 0
        !          7362:          || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE)
        !          7363:        break;
        !          7364:       else if (!HAVE_cmpstrsi)
        !          7365:        break;
        !          7366:       {
        !          7367:        tree arg1 = TREE_VALUE (arglist);
        !          7368:        tree arg2 = TREE_VALUE (TREE_CHAIN (arglist));
        !          7369:        tree offset;
        !          7370:        tree len, len2;
        !          7371: 
        !          7372:        len = c_strlen (arg1);
        !          7373:        if (len)
        !          7374:          len = size_binop (PLUS_EXPR, integer_one_node, len);
        !          7375:        len2 = c_strlen (arg2);
        !          7376:        if (len2)
        !          7377:          len2 = size_binop (PLUS_EXPR, integer_one_node, len2);
        !          7378: 
        !          7379:        /* If we don't have a constant length for the first, use the length
        !          7380:           of the second, if we know it.  We don't require a constant for
        !          7381:           this case; some cost analysis could be done if both are available
        !          7382:           but neither is constant.  For now, assume they're equally cheap.
        !          7383: 
        !          7384:           If both strings have constant lengths, use the smaller.  This
        !          7385:           could arise if optimization results in strcpy being called with
        !          7386:           two fixed strings, or if the code was machine-generated.  We should
        !          7387:           add some code to the `memcmp' handler below to deal with such
        !          7388:           situations, someday.  */
        !          7389:        if (!len || TREE_CODE (len) != INTEGER_CST)
        !          7390:          {
        !          7391:            if (len2)
        !          7392:              len = len2;
        !          7393:            else if (len == 0)
        !          7394:              break;
        !          7395:          }
        !          7396:        else if (len2 && TREE_CODE (len2) == INTEGER_CST)
        !          7397:          {
        !          7398:            if (tree_int_cst_lt (len2, len))
        !          7399:              len = len2;
        !          7400:          }
        !          7401: 
        !          7402:        chainon (arglist, build_tree_list (NULL_TREE, len));
        !          7403:       }
        !          7404: 
        !          7405:       /* Drops in.  */
        !          7406:     case BUILT_IN_MEMCMP:
        !          7407:       /* If not optimizing, call the library function.  */
        !          7408:       if (!optimize)
        !          7409:        break;
        !          7410: 
        !          7411:       if (arglist == 0
        !          7412:          /* Arg could be non-pointer if user redeclared this fcn wrong.  */
        !          7413:          || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
        !          7414:          || TREE_CHAIN (arglist) == 0
        !          7415:          || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE
        !          7416:          || TREE_CHAIN (TREE_CHAIN (arglist)) == 0
        !          7417:          || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))))) != INTEGER_TYPE)
        !          7418:        break;
        !          7419:       else if (!HAVE_cmpstrsi)
        !          7420:        break;
        !          7421:       {
        !          7422:        tree arg1 = TREE_VALUE (arglist);
        !          7423:        tree arg2 = TREE_VALUE (TREE_CHAIN (arglist));
        !          7424:        tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
        !          7425:        rtx result;
        !          7426: 
        !          7427:        int arg1_align
        !          7428:          = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
        !          7429:        int arg2_align
        !          7430:          = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
        !          7431:        enum machine_mode insn_mode
        !          7432:          = insn_operand_mode[(int) CODE_FOR_cmpstrsi][0];
        !          7433: 
        !          7434:        /* If we don't have POINTER_TYPE, call the function.  */
        !          7435:        if (arg1_align == 0 || arg2_align == 0)
        !          7436:          {
        !          7437:            if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRCMP)
        !          7438:              TREE_CHAIN (TREE_CHAIN (arglist)) = 0;
        !          7439:            break;
        !          7440:          }
        !          7441: 
        !          7442:        /* Make a place to write the result of the instruction.  */
        !          7443:        result = target;
        !          7444:        if (! (result != 0
        !          7445:               && GET_CODE (result) == REG && GET_MODE (result) == insn_mode
        !          7446:               && REGNO (result) >= FIRST_PSEUDO_REGISTER))
        !          7447:          result = gen_reg_rtx (insn_mode);
        !          7448: 
        !          7449:        emit_insn (gen_cmpstrsi (result,
        !          7450:                                 gen_rtx (MEM, BLKmode,
        !          7451:                                          expand_expr (arg1, NULL_RTX, Pmode,
        !          7452:                                                       EXPAND_NORMAL)),
        !          7453:                                 gen_rtx (MEM, BLKmode,
        !          7454:                                          expand_expr (arg2, NULL_RTX, Pmode,
        !          7455:                                                       EXPAND_NORMAL)),
        !          7456:                                 expand_expr (len, NULL_RTX, VOIDmode, 0),
        !          7457:                                 GEN_INT (MIN (arg1_align, arg2_align))));
        !          7458: 
        !          7459:        /* Return the value in the proper mode for this function.  */
        !          7460:        mode = TYPE_MODE (TREE_TYPE (exp));
        !          7461:        if (GET_MODE (result) == mode)
        !          7462:          return result;
        !          7463:        else if (target != 0)
        !          7464:          {
        !          7465:            convert_move (target, result, 0);
        !          7466:            return target;
        !          7467:          }
        !          7468:        else
        !          7469:          return convert_to_mode (mode, result, 0);
        !          7470:       }        
        !          7471: #else
        !          7472:     case BUILT_IN_STRCMP:
        !          7473:     case BUILT_IN_MEMCMP:
        !          7474:       break;
        !          7475: #endif
        !          7476: 
        !          7477:     default:                   /* just do library call, if unknown builtin */
        !          7478:       error ("built-in function `%s' not currently supported",
        !          7479:             IDENTIFIER_POINTER (DECL_NAME (fndecl)));
        !          7480:     }
        !          7481: 
        !          7482:   /* The switch statement above can drop through to cause the function
        !          7483:      to be called normally.  */
        !          7484: 
        !          7485:   return expand_call (exp, target, ignore);
        !          7486: }
        !          7487: 
        !          7488: /* Built-in functions to perform an untyped call and return.  */
        !          7489: 
        !          7490: /* For each register that may be used for calling a function, this
        !          7491:    gives a mode used to copy the register's value.  VOIDmode indicates
        !          7492:    the register is not used for calling a function.  If the machine
        !          7493:    has register windows, this gives only the outbound registers.
        !          7494:    INCOMING_REGNO gives the corresponding inbound register.  */
        !          7495: static enum machine_mode apply_args_mode[FIRST_PSEUDO_REGISTER];
        !          7496: 
        !          7497: /* For each register that may be used for returning values, this gives
        !          7498:    a mode used to copy the register's value.  VOIDmode indicates the
        !          7499:    register is not used for returning values.  If the machine has
        !          7500:    register windows, this gives only the outbound registers.
        !          7501:    INCOMING_REGNO gives the corresponding inbound register.  */
        !          7502: static enum machine_mode apply_result_mode[FIRST_PSEUDO_REGISTER];
        !          7503: 
        !          7504: /* For each register that may be used for calling a function, this
        !          7505:    gives the offset of that register into the block returned by
        !          7506:    __bultin_apply_args.  0 indicates that the register is not
        !          7507:    used for calling a function. */
        !          7508: static int apply_args_reg_offset[FIRST_PSEUDO_REGISTER];
        !          7509: 
        !          7510: /* Return the offset of register REGNO into the block returned by 
        !          7511:    __builtin_apply_args.  This is not declared static, since it is
        !          7512:    needed in objc-act.c. */
        !          7513: 
        !          7514: int 
        !          7515: apply_args_register_offset (regno)
        !          7516:      int regno;
        !          7517: {
        !          7518:   apply_args_size ();
        !          7519: 
        !          7520:   /* Arguments are always put in outgoing registers (in the argument
        !          7521:      block) if such make sense. */
        !          7522: #ifdef OUTGOING_REGNO
        !          7523:   regno = OUTGOING_REGNO(regno);
        !          7524: #endif
        !          7525:   return apply_args_reg_offset[regno];
        !          7526: }
        !          7527: 
        !          7528: /* Return the size required for the block returned by __builtin_apply_args,
        !          7529:    and initialize apply_args_mode.  */
        !          7530: 
        !          7531: static int
        !          7532: apply_args_size ()
        !          7533: {
        !          7534:   static int size = -1;
        !          7535:   int align, regno;
        !          7536:   enum machine_mode mode;
        !          7537: 
        !          7538:   /* The values computed by this function never change.  */
        !          7539:   if (size < 0)
        !          7540:     {
        !          7541:       /* The first value is the incoming arg-pointer.  */
        !          7542:       size = GET_MODE_SIZE (Pmode);
        !          7543: 
        !          7544:       /* The second value is the structure value address unless this is
        !          7545:         passed as an "invisible" first argument.  */
        !          7546:       if (struct_value_rtx)
        !          7547:        size += GET_MODE_SIZE (Pmode);
        !          7548: 
        !          7549:       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
        !          7550:        if (FUNCTION_ARG_REGNO_P (regno))
        !          7551:          {
        !          7552:            /* Search for the proper mode for copying this register's
        !          7553:               value.  I'm not sure this is right, but it works so far.  */
        !          7554:            enum machine_mode best_mode = VOIDmode;
        !          7555: 
        !          7556:            for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
        !          7557:                 mode != VOIDmode;
        !          7558:                 mode = GET_MODE_WIDER_MODE (mode))
        !          7559:              if (HARD_REGNO_MODE_OK (regno, mode)
        !          7560:                  && HARD_REGNO_NREGS (regno, mode) == 1)
        !          7561:                best_mode = mode;
        !          7562: 
        !          7563:            if (best_mode == VOIDmode)
        !          7564:              for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
        !          7565:                   mode != VOIDmode;
        !          7566:                   mode = GET_MODE_WIDER_MODE (mode))
        !          7567:                if (HARD_REGNO_MODE_OK (regno, mode)
        !          7568:                    && (mov_optab->handlers[(int) mode].insn_code
        !          7569:                        != CODE_FOR_nothing))
        !          7570:                  best_mode = mode;
        !          7571: 
        !          7572:            mode = best_mode;
        !          7573:            if (mode == VOIDmode)
        !          7574:              abort ();
        !          7575: 
        !          7576:            align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
        !          7577:            if (size % align != 0)
        !          7578:              size = CEIL (size, align) * align;
        !          7579:            apply_args_reg_offset[regno] = size;
        !          7580:            size += GET_MODE_SIZE (mode);
        !          7581:            apply_args_mode[regno] = mode;
        !          7582:          }
        !          7583:        else
        !          7584:          {
        !          7585:            apply_args_mode[regno] = VOIDmode;
        !          7586:            apply_args_reg_offset[regno] = 0;
        !          7587:          }
        !          7588:     }
        !          7589:   return size;
        !          7590: }
        !          7591: 
        !          7592: /* Return the size required for the block returned by __builtin_apply,
        !          7593:    and initialize apply_result_mode.  */
        !          7594: 
        !          7595: static int
        !          7596: apply_result_size ()
        !          7597: {
        !          7598:   static int size = -1;
        !          7599:   int align, regno;
        !          7600:   enum machine_mode mode;
        !          7601: 
        !          7602:   /* The values computed by this function never change.  */
        !          7603:   if (size < 0)
        !          7604:     {
        !          7605:       size = 0;
        !          7606: 
        !          7607:       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
        !          7608:        if (FUNCTION_VALUE_REGNO_P (regno))
        !          7609:          {
        !          7610:            /* Search for the proper mode for copying this register's
        !          7611:               value.  I'm not sure this is right, but it works so far.  */
        !          7612:            enum machine_mode best_mode = VOIDmode;
        !          7613: 
        !          7614:            for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
        !          7615:                 mode != TImode;
        !          7616:                 mode = GET_MODE_WIDER_MODE (mode))
        !          7617:              if (HARD_REGNO_MODE_OK (regno, mode))
        !          7618:                best_mode = mode;
        !          7619: 
        !          7620:            if (best_mode == VOIDmode)
        !          7621:              for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
        !          7622:                   mode != VOIDmode;
        !          7623:                   mode = GET_MODE_WIDER_MODE (mode))
        !          7624:                if (HARD_REGNO_MODE_OK (regno, mode)
        !          7625:                    && (mov_optab->handlers[(int) mode].insn_code
        !          7626:                        != CODE_FOR_nothing))
        !          7627:                  best_mode = mode;
        !          7628: 
        !          7629:            mode = best_mode;
        !          7630:            if (mode == VOIDmode)
        !          7631:              abort ();
        !          7632: 
        !          7633:            align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
        !          7634:            if (size % align != 0)
        !          7635:              size = CEIL (size, align) * align;
        !          7636:            size += GET_MODE_SIZE (mode);
        !          7637:            apply_result_mode[regno] = mode;
        !          7638:          }
        !          7639:        else
        !          7640:          apply_result_mode[regno] = VOIDmode;
        !          7641: 
        !          7642:       /* Allow targets that use untyped_call and untyped_return to override
        !          7643:         the size so that machine-specific information can be stored here.  */
        !          7644: #ifdef APPLY_RESULT_SIZE
        !          7645:       size = APPLY_RESULT_SIZE;
        !          7646: #endif
        !          7647:     }
        !          7648:   return size;
        !          7649: }
        !          7650: 
        !          7651: #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
        !          7652: /* Create a vector describing the result block RESULT.  If SAVEP is true,
        !          7653:    the result block is used to save the values; otherwise it is used to
        !          7654:    restore the values.  */
        !          7655: 
        !          7656: static rtx
        !          7657: result_vector (savep, result)
        !          7658:      int savep;
        !          7659:      rtx result;
        !          7660: {
        !          7661:   int regno, size, align, nelts;
        !          7662:   enum machine_mode mode;
        !          7663:   rtx reg, mem;
        !          7664:   rtx *savevec = (rtx *) alloca (FIRST_PSEUDO_REGISTER * sizeof (rtx));
        !          7665:   
        !          7666:   size = nelts = 0;
        !          7667:   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
        !          7668:     if ((mode = apply_result_mode[regno]) != VOIDmode)
        !          7669:       {
        !          7670:        align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
        !          7671:        if (size % align != 0)
        !          7672:          size = CEIL (size, align) * align;
        !          7673:        reg = gen_rtx (REG, mode, savep ? INCOMING_REGNO (regno) : regno);
        !          7674:        mem = change_address (result, mode,
        !          7675:                              plus_constant (XEXP (result, 0), size));
        !          7676:        savevec[nelts++] = (savep
        !          7677:                            ? gen_rtx (SET, VOIDmode, mem, reg)
        !          7678:                            : gen_rtx (SET, VOIDmode, reg, mem));
        !          7679:        size += GET_MODE_SIZE (mode);
        !          7680:       }
        !          7681:   return gen_rtx (PARALLEL, VOIDmode, gen_rtvec_v (nelts, savevec));
        !          7682: }
        !          7683: #endif /* HAVE_untyped_call or HAVE_untyped_return */
        !          7684: 
        !          7685: /* Save the state required to perform an untyped call with the same
        !          7686:    arguments as were passed to the current function.  */
        !          7687: 
        !          7688: static rtx
        !          7689: expand_builtin_apply_args ()
        !          7690: {
        !          7691:   rtx registers;
        !          7692:   int size, align, regno;
        !          7693:   enum machine_mode mode;
        !          7694: 
        !          7695:   /* Create a block where the arg-pointer, structure value address,
        !          7696:      and argument registers can be saved.  */
        !          7697:   registers = assign_stack_local (BLKmode, apply_args_size (), -1);
        !          7698: 
        !          7699:   /* Walk past the arg-pointer and structure value address.  */
        !          7700:   size = GET_MODE_SIZE (Pmode);
        !          7701:   if (struct_value_rtx)
        !          7702:     size += GET_MODE_SIZE (Pmode);
        !          7703: 
        !          7704:   /* Save each register used in calling a function to the block.  */
        !          7705:   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
        !          7706:     if ((mode = apply_args_mode[regno]) != VOIDmode)
        !          7707:       {
        !          7708:        align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
        !          7709:        if (size % align != 0)
        !          7710:          size = CEIL (size, align) * align;
        !          7711:        emit_move_insn (change_address (registers, mode,
        !          7712:                                        plus_constant (XEXP (registers, 0),
        !          7713:                                                       size)),
        !          7714:                        gen_rtx (REG, mode, INCOMING_REGNO (regno)));
        !          7715:        size += GET_MODE_SIZE (mode);
        !          7716:       }
        !          7717: 
        !          7718:   /* Save the arg pointer to the block.  */
        !          7719:   emit_move_insn (change_address (registers, Pmode, XEXP (registers, 0)),
        !          7720:                  copy_to_reg (virtual_incoming_args_rtx));
        !          7721:   size = GET_MODE_SIZE (Pmode);
        !          7722: 
        !          7723:   /* Save the structure value address unless this is passed as an
        !          7724:      "invisible" first argument.  */
        !          7725:   if (struct_value_incoming_rtx)
        !          7726:     {
        !          7727:       emit_move_insn (change_address (registers, Pmode,
        !          7728:                                      plus_constant (XEXP (registers, 0),
        !          7729:                                                     size)),
        !          7730:                      copy_to_reg (struct_value_incoming_rtx));
        !          7731:       size += GET_MODE_SIZE (Pmode);
        !          7732:     }
        !          7733: 
        !          7734:   /* Return the address of the block.  */
        !          7735:   return copy_addr_to_reg (XEXP (registers, 0));
        !          7736: }
        !          7737: 
        !          7738: /* Perform an untyped call and save the state required to perform an
        !          7739:    untyped return of whatever value was returned by the given function.  */
        !          7740: 
        !          7741: static rtx
        !          7742: expand_builtin_apply (function, arguments, argsize)
        !          7743:      rtx function, arguments, argsize;
        !          7744: {
        !          7745:   int size, align, regno;
        !          7746:   enum machine_mode mode;
        !          7747:   rtx incoming_args, result, reg, dest, call_insn;
        !          7748:   rtx old_stack_level = 0;
        !          7749:   rtx use_insns = 0;
        !          7750: 
        !          7751:   /* Create a block where the return registers can be saved.  */
        !          7752:   result = assign_stack_local (BLKmode, apply_result_size (), -1);
        !          7753: 
        !          7754:   /* ??? The argsize value should be adjusted here.  */
        !          7755: 
        !          7756:   /* Fetch the arg pointer from the ARGUMENTS block.  */
        !          7757:   incoming_args = gen_reg_rtx (Pmode);
        !          7758:   emit_move_insn (incoming_args,
        !          7759:                  gen_rtx (MEM, Pmode, arguments));
        !          7760: #ifndef STACK_GROWS_DOWNWARD
        !          7761:   incoming_args = expand_binop (Pmode, sub_optab, incoming_args, argsize,
        !          7762:                                incoming_args, 0, OPTAB_LIB_WIDEN);
        !          7763: #endif
        !          7764: 
        !          7765:   /* Perform postincrements before actually calling the function.  */
        !          7766:   emit_queue ();
        !          7767: 
        !          7768:   /* Push a new argument block and copy the arguments.  */
        !          7769:   do_pending_stack_adjust ();
        !          7770:   emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
        !          7771: 
        !          7772:   /* Push a block of memory onto the stack to store the memory arguments.
        !          7773:      Save the address in a register, and copy the memory arguments.  ??? I
        !          7774:      haven't figured out how the calling convention macros effect this,
        !          7775:      but it's likely that the source and/or destination addresses in
        !          7776:      the block copy will need updating in machine specific ways.  */
        !          7777:   dest = copy_addr_to_reg (push_block (argsize, 0, 0));
        !          7778:   emit_block_move (gen_rtx (MEM, BLKmode, dest),
        !          7779:                   gen_rtx (MEM, BLKmode, incoming_args),
        !          7780:                   argsize,
        !          7781:                   PARM_BOUNDARY / BITS_PER_UNIT);
        !          7782: 
        !          7783:   /* Refer to the argument block.  */
        !          7784:   apply_args_size ();
        !          7785:   arguments = gen_rtx (MEM, BLKmode, arguments);
        !          7786: 
        !          7787:   /* Walk past the arg-pointer and structure value address.  */
        !          7788:   size = GET_MODE_SIZE (Pmode);
        !          7789:   if (struct_value_rtx)
        !          7790:     size += GET_MODE_SIZE (Pmode);
        !          7791: 
        !          7792:   /* Restore each of the registers previously saved.  Make USE insns
        !          7793:      for each of these registers for use in making the call.  */
        !          7794:   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
        !          7795:     if ((mode = apply_args_mode[regno]) != VOIDmode)
        !          7796:       {
        !          7797:        align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
        !          7798:        if (size % align != 0)
        !          7799:          size = CEIL (size, align) * align;
        !          7800:        reg = gen_rtx (REG, mode, regno);
        !          7801:        emit_move_insn (reg,
        !          7802:                        change_address (arguments, mode,
        !          7803:                                        plus_constant (XEXP (arguments, 0),
        !          7804:                                                       size)));
        !          7805: 
        !          7806:        push_to_sequence (use_insns);
        !          7807:        emit_insn (gen_rtx (USE, VOIDmode, reg));
        !          7808:        use_insns = get_insns ();
        !          7809:        end_sequence ();
        !          7810:        size += GET_MODE_SIZE (mode);
        !          7811:       }
        !          7812: 
        !          7813:   /* Restore the structure value address unless this is passed as an
        !          7814:      "invisible" first argument.  */
        !          7815:   size = GET_MODE_SIZE (Pmode);
        !          7816:   if (struct_value_rtx)
        !          7817:     {
        !          7818:       rtx value = gen_reg_rtx (Pmode);
        !          7819:       emit_move_insn (value,
        !          7820:                      change_address (arguments, Pmode,
        !          7821:                                      plus_constant (XEXP (arguments, 0),
        !          7822:                                                     size)));
        !          7823:       emit_move_insn (struct_value_rtx, value);
        !          7824:       if (GET_CODE (struct_value_rtx) == REG)
        !          7825:        {
        !          7826:          push_to_sequence (use_insns);
        !          7827:          emit_insn (gen_rtx (USE, VOIDmode, struct_value_rtx));
        !          7828:          use_insns = get_insns ();
        !          7829:          end_sequence ();
        !          7830:        }
        !          7831:       size += GET_MODE_SIZE (Pmode);
        !          7832:     }
        !          7833: 
        !          7834:   /* All arguments and registers used for the call are set up by now!  */
        !          7835:   function = prepare_call_address (function, NULL_TREE, &use_insns);
        !          7836: 
        !          7837:   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
        !          7838:      and we don't want to load it into a register as an optimization,
        !          7839:      because prepare_call_address already did it if it should be done.  */
        !          7840:   if (GET_CODE (function) != SYMBOL_REF)
        !          7841:     function = memory_address (FUNCTION_MODE, function);
        !          7842: 
        !          7843:   /* Generate the actual call instruction and save the return value.  */
        !          7844: #ifdef HAVE_untyped_call
        !          7845:   if (HAVE_untyped_call)
        !          7846:     emit_call_insn (gen_untyped_call (gen_rtx (MEM, FUNCTION_MODE, function),
        !          7847:                                      result, result_vector (1, result)));
        !          7848:   else
        !          7849: #endif
        !          7850: #ifdef HAVE_call_value
        !          7851:   if (HAVE_call_value)
        !          7852:     {
        !          7853:       rtx valreg = 0;
        !          7854: 
        !          7855:       /* Locate the unique return register.  It is not possible to
        !          7856:         express a call that sets more than one return register using
        !          7857:         call_value; use untyped_call for that.  In fact, untyped_call
        !          7858:         only needs to save the return registers in the given block.  */
        !          7859:       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
        !          7860:        if ((mode = apply_result_mode[regno]) != VOIDmode)
        !          7861:          {
        !          7862:            if (valreg)
        !          7863:              abort (); /* HAVE_untyped_call required.  */
        !          7864:            valreg = gen_rtx (REG, mode, regno);
        !          7865:          }
        !          7866: 
        !          7867:       emit_call_insn (gen_call_value (valreg,
        !          7868:                                      gen_rtx (MEM, FUNCTION_MODE, function),
        !          7869:                                      const0_rtx, NULL_RTX, const0_rtx));
        !          7870: 
        !          7871:       emit_move_insn (change_address (result, GET_MODE (valreg),
        !          7872:                                      XEXP (result, 0)),
        !          7873:                      valreg);
        !          7874:     }
        !          7875:   else
        !          7876: #endif
        !          7877:     abort ();
        !          7878: 
        !          7879:   /* Find the CALL insn we just emitted and write the USE insns before it.  */
        !          7880:   for (call_insn = get_last_insn ();
        !          7881:        call_insn && GET_CODE (call_insn) != CALL_INSN;
        !          7882:        call_insn = PREV_INSN (call_insn))
        !          7883:     ;
        !          7884: 
        !          7885:   if (! call_insn)
        !          7886:     abort ();
        !          7887: 
        !          7888:   /* Put the USE insns before the CALL.  */
        !          7889:   emit_insns_before (use_insns, call_insn);
        !          7890: 
        !          7891:   /* Restore the stack.  */
        !          7892:   emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
        !          7893: 
        !          7894:   /* Return the address of the result block.  */
        !          7895:   return copy_addr_to_reg (XEXP (result, 0));
        !          7896: }
        !          7897: 
        !          7898: /* Perform an untyped return.  */
        !          7899: 
        !          7900: static void
        !          7901: expand_builtin_return (result)
        !          7902:      rtx result;
        !          7903: {
        !          7904:   int size, align, regno;
        !          7905:   enum machine_mode mode;
        !          7906:   rtx reg;
        !          7907:   rtx use_insns = 0;
        !          7908: 
        !          7909:   apply_result_size ();
        !          7910:   result = gen_rtx (MEM, BLKmode, result);
        !          7911: 
        !          7912: #ifdef HAVE_untyped_return
        !          7913:   if (HAVE_untyped_return)
        !          7914:     {
        !          7915:       emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
        !          7916:       emit_barrier ();
        !          7917:       return;
        !          7918:     }
        !          7919: #endif
        !          7920: 
        !          7921:   /* Restore the return value and note that each value is used.  */
        !          7922:   size = 0;
        !          7923:   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
        !          7924:     if ((mode = apply_result_mode[regno]) != VOIDmode)
        !          7925:       {
        !          7926:        align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
        !          7927:        if (size % align != 0)
        !          7928:          size = CEIL (size, align) * align;
        !          7929:        reg = gen_rtx (REG, mode, INCOMING_REGNO (regno));
        !          7930:        emit_move_insn (reg,
        !          7931:                        change_address (result, mode,
        !          7932:                                        plus_constant (XEXP (result, 0),
        !          7933:                                                       size)));
        !          7934: 
        !          7935:        push_to_sequence (use_insns);
        !          7936:        emit_insn (gen_rtx (USE, VOIDmode, reg));
        !          7937:        use_insns = get_insns ();
        !          7938:        end_sequence ();
        !          7939:        size += GET_MODE_SIZE (mode);
        !          7940:       }
        !          7941: 
        !          7942:   /* Put the USE insns before the return.  */
        !          7943:   emit_insns (use_insns);
        !          7944: 
        !          7945:   /* Return whatever values was restored by jumping directly to the end
        !          7946:      of the function.  */
        !          7947:   expand_null_return ();
        !          7948: }
        !          7949: 
        !          7950: /* Expand code for a post- or pre- increment or decrement
        !          7951:    and return the RTX for the result.
        !          7952:    POST is 1 for postinc/decrements and 0 for preinc/decrements.  */
        !          7953: 
        !          7954: static rtx
        !          7955: expand_increment (exp, post)
        !          7956:      register tree exp;
        !          7957:      int post;
        !          7958: {
        !          7959:   register rtx op0, op1;
        !          7960:   register rtx temp, value;
        !          7961:   register tree incremented = TREE_OPERAND (exp, 0);
        !          7962:   optab this_optab = add_optab;
        !          7963:   int icode;
        !          7964:   enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
        !          7965:   int op0_is_copy = 0;
        !          7966:   int single_insn = 0;
        !          7967:   /* 1 means we can't store into OP0 directly,
        !          7968:      because it is a subreg narrower than a word,
        !          7969:      and we don't dare clobber the rest of the word.  */
        !          7970:   int bad_subreg = 0;
        !          7971: 
        !          7972:   if (output_bytecode)
        !          7973:     {
        !          7974:       bc_expand_expr (exp);
        !          7975:       return NULL_RTX;
        !          7976:     }
        !          7977: 
        !          7978:   /* Stabilize any component ref that might need to be
        !          7979:      evaluated more than once below.  */
        !          7980:   if (!post
        !          7981:       || TREE_CODE (incremented) == BIT_FIELD_REF
        !          7982:       || (TREE_CODE (incremented) == COMPONENT_REF
        !          7983:          && (TREE_CODE (TREE_OPERAND (incremented, 0)) != INDIRECT_REF
        !          7984:              || DECL_BIT_FIELD (TREE_OPERAND (incremented, 1)))))
        !          7985:     incremented = stabilize_reference (incremented);
        !          7986:   /* Nested *INCREMENT_EXPRs can happen in C++.  We must force innermost
        !          7987:      ones into save exprs so that they don't accidentally get evaluated
        !          7988:      more than once by the code below.  */
        !          7989:   if (TREE_CODE (incremented) == PREINCREMENT_EXPR
        !          7990:       || TREE_CODE (incremented) == PREDECREMENT_EXPR)
        !          7991:     incremented = save_expr (incremented);
        !          7992: 
        !          7993:   /* Compute the operands as RTX.
        !          7994:      Note whether OP0 is the actual lvalue or a copy of it:
        !          7995:      I believe it is a copy iff it is a register or subreg
        !          7996:      and insns were generated in computing it.   */
        !          7997: 
        !          7998:   temp = get_last_insn ();
        !          7999:   op0 = expand_expr (incremented, NULL_RTX, VOIDmode, 0);
        !          8000: 
        !          8001:   /* If OP0 is a SUBREG made for a promoted variable, we cannot increment
        !          8002:      in place but intead must do sign- or zero-extension during assignment,
        !          8003:      so we copy it into a new register and let the code below use it as
        !          8004:      a copy.
        !          8005: 
        !          8006:      Note that we can safely modify this SUBREG since it is know not to be
        !          8007:      shared (it was made by the expand_expr call above).  */
        !          8008: 
        !          8009:   if (GET_CODE (op0) == SUBREG && SUBREG_PROMOTED_VAR_P (op0))
        !          8010:     SUBREG_REG (op0) = copy_to_reg (SUBREG_REG (op0));
        !          8011:   else if (GET_CODE (op0) == SUBREG
        !          8012:           && GET_MODE_BITSIZE (GET_MODE (op0)) < BITS_PER_WORD)
        !          8013:     bad_subreg = 1;
        !          8014: 
        !          8015:   op0_is_copy = ((GET_CODE (op0) == SUBREG || GET_CODE (op0) == REG)
        !          8016:                 && temp != get_last_insn ());
        !          8017:   op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
        !          8018: 
        !          8019:   /* Decide whether incrementing or decrementing.  */
        !          8020:   if (TREE_CODE (exp) == POSTDECREMENT_EXPR
        !          8021:       || TREE_CODE (exp) == PREDECREMENT_EXPR)
        !          8022:     this_optab = sub_optab;
        !          8023: 
        !          8024:   /* Convert decrement by a constant into a negative increment.  */
        !          8025:   if (this_optab == sub_optab
        !          8026:       && GET_CODE (op1) == CONST_INT)
        !          8027:     {
        !          8028:       op1 = GEN_INT (- INTVAL (op1));
        !          8029:       this_optab = add_optab;
        !          8030:     }
        !          8031: 
        !          8032:   /* For a preincrement, see if we can do this with a single instruction.  */
        !          8033:   if (!post)
        !          8034:     {
        !          8035:       icode = (int) this_optab->handlers[(int) mode].insn_code;
        !          8036:       if (icode != (int) CODE_FOR_nothing
        !          8037:          /* Make sure that OP0 is valid for operands 0 and 1
        !          8038:             of the insn we want to queue.  */
        !          8039:          && (*insn_operand_predicate[icode][0]) (op0, mode)
        !          8040:          && (*insn_operand_predicate[icode][1]) (op0, mode)
        !          8041:          && (*insn_operand_predicate[icode][2]) (op1, mode))
        !          8042:        single_insn = 1;
        !          8043:     }
        !          8044: 
        !          8045:   /* If OP0 is not the actual lvalue, but rather a copy in a register,
        !          8046:      then we cannot just increment OP0.  We must therefore contrive to
        !          8047:      increment the original value.  Then, for postincrement, we can return
        !          8048:      OP0 since it is a copy of the old value.  For preincrement, expand here
        !          8049:      unless we can do it with a single insn.
        !          8050: 
        !          8051:      Likewise if storing directly into OP0 would clobber high bits
        !          8052:      we need to preserve (bad_subreg).  */
        !          8053:   if (op0_is_copy || (!post && !single_insn) || bad_subreg)
        !          8054:     {
        !          8055:       /* This is the easiest way to increment the value wherever it is.
        !          8056:         Problems with multiple evaluation of INCREMENTED are prevented
        !          8057:         because either (1) it is a component_ref or preincrement,
        !          8058:         in which case it was stabilized above, or (2) it is an array_ref
        !          8059:         with constant index in an array in a register, which is
        !          8060:         safe to reevaluate.  */
        !          8061:       tree newexp = build (((TREE_CODE (exp) == POSTDECREMENT_EXPR
        !          8062:                             || TREE_CODE (exp) == PREDECREMENT_EXPR)
        !          8063:                            ? MINUS_EXPR : PLUS_EXPR),
        !          8064:                           TREE_TYPE (exp),
        !          8065:                           incremented,
        !          8066:                           TREE_OPERAND (exp, 1));
        !          8067:       temp = expand_assignment (incremented, newexp, ! post, 0);
        !          8068:       return post ? op0 : temp;
        !          8069:     }
        !          8070: 
        !          8071:   if (post)
        !          8072:     {
        !          8073:       /* We have a true reference to the value in OP0.
        !          8074:         If there is an insn to add or subtract in this mode, queue it.
        !          8075:         Queueing the increment insn avoids the register shuffling
        !          8076:         that often results if we must increment now and first save
        !          8077:         the old value for subsequent use.  */
        !          8078: 
        !          8079: #if 0  /* Turned off to avoid making extra insn for indexed memref.  */
        !          8080:       op0 = stabilize (op0);
        !          8081: #endif
        !          8082: 
        !          8083:       icode = (int) this_optab->handlers[(int) mode].insn_code;
        !          8084:       if (icode != (int) CODE_FOR_nothing
        !          8085:          /* Make sure that OP0 is valid for operands 0 and 1
        !          8086:             of the insn we want to queue.  */
        !          8087:          && (*insn_operand_predicate[icode][0]) (op0, mode)
        !          8088:          && (*insn_operand_predicate[icode][1]) (op0, mode))
        !          8089:        {
        !          8090:          if (! (*insn_operand_predicate[icode][2]) (op1, mode))
        !          8091:            op1 = force_reg (mode, op1);
        !          8092: 
        !          8093:          return enqueue_insn (op0, GEN_FCN (icode) (op0, op0, op1));
        !          8094:        }
        !          8095:     }
        !          8096: 
        !          8097:   /* Preincrement, or we can't increment with one simple insn.  */
        !          8098:   if (post)
        !          8099:     /* Save a copy of the value before inc or dec, to return it later.  */
        !          8100:     temp = value = copy_to_reg (op0);
        !          8101:   else
        !          8102:     /* Arrange to return the incremented value.  */
        !          8103:     /* Copy the rtx because expand_binop will protect from the queue,
        !          8104:        and the results of that would be invalid for us to return
        !          8105:        if our caller does emit_queue before using our result.  */
        !          8106:     temp = copy_rtx (value = op0);
        !          8107: 
        !          8108:   /* Increment however we can.  */
        !          8109:   op1 = expand_binop (mode, this_optab, value, op1, op0,
        !          8110:                      TREE_UNSIGNED (TREE_TYPE (exp)), OPTAB_LIB_WIDEN);
        !          8111:   /* Make sure the value is stored into OP0.  */
        !          8112:   if (op1 != op0)
        !          8113:     emit_move_insn (op0, op1);
        !          8114: 
        !          8115:   return temp;
        !          8116: }
        !          8117: 
        !          8118: /* Expand all function calls contained within EXP, innermost ones first.
        !          8119:    But don't look within expressions that have sequence points.
        !          8120:    For each CALL_EXPR, record the rtx for its value
        !          8121:    in the CALL_EXPR_RTL field.  */
        !          8122: 
        !          8123: static void
        !          8124: preexpand_calls (exp)
        !          8125:      tree exp;
        !          8126: {
        !          8127:   register int nops, i;
        !          8128:   int type = TREE_CODE_CLASS (TREE_CODE (exp));
        !          8129: 
        !          8130:   if (! do_preexpand_calls)
        !          8131:     return;
        !          8132: 
        !          8133:   /* Only expressions and references can contain calls.  */
        !          8134: 
        !          8135:   if (type != 'e' && type != '<' && type != '1' && type != '2' && type != 'r')
        !          8136:     return;
        !          8137: 
        !          8138:   switch (TREE_CODE (exp))
        !          8139:     {
        !          8140:     case CALL_EXPR:
        !          8141:       /* Do nothing if already expanded.  */
        !          8142:       if (CALL_EXPR_RTL (exp) != 0)
        !          8143:        return;
        !          8144: 
        !          8145:       /* Do nothing to built-in functions.  */
        !          8146:       if (TREE_CODE (TREE_OPERAND (exp, 0)) != ADDR_EXPR
        !          8147:          || TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) != FUNCTION_DECL
        !          8148:          || ! DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
        !          8149:        CALL_EXPR_RTL (exp) = expand_call (exp, NULL_RTX, 0);
        !          8150:       return;
        !          8151: 
        !          8152:     case COMPOUND_EXPR:
        !          8153:     case COND_EXPR:
        !          8154:     case TRUTH_ANDIF_EXPR:
        !          8155:     case TRUTH_ORIF_EXPR:
        !          8156:       /* If we find one of these, then we can be sure
        !          8157:         the adjust will be done for it (since it makes jumps).
        !          8158:         Do it now, so that if this is inside an argument
        !          8159:         of a function, we don't get the stack adjustment
        !          8160:         after some other args have already been pushed.  */
        !          8161:       do_pending_stack_adjust ();
        !          8162:       return;
        !          8163: 
        !          8164:     case BLOCK:
        !          8165:     case RTL_EXPR:
        !          8166:     case WITH_CLEANUP_EXPR:
        !          8167:       return;
        !          8168: 
        !          8169:     case SAVE_EXPR:
        !          8170:       if (SAVE_EXPR_RTL (exp) != 0)
        !          8171:        return;
        !          8172:     }
        !          8173: 
        !          8174:   nops = tree_code_length[(int) TREE_CODE (exp)];
        !          8175:   for (i = 0; i < nops; i++)
        !          8176:     if (TREE_OPERAND (exp, i) != 0)
        !          8177:       {
        !          8178:        type = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i)));
        !          8179:        if (type == 'e' || type == '<' || type == '1' || type == '2'
        !          8180:            || type == 'r')
        !          8181:          preexpand_calls (TREE_OPERAND (exp, i));
        !          8182:       }
        !          8183: }
        !          8184: 
        !          8185: /* At the start of a function, record that we have no previously-pushed
        !          8186:    arguments waiting to be popped.  */
        !          8187: 
        !          8188: void
        !          8189: init_pending_stack_adjust ()
        !          8190: {
        !          8191:   pending_stack_adjust = 0;
        !          8192: }
        !          8193: 
        !          8194: /* When exiting from function, if safe, clear out any pending stack adjust
        !          8195:    so the adjustment won't get done.  */
        !          8196: 
        !          8197: void
        !          8198: clear_pending_stack_adjust ()
        !          8199: {
        !          8200: #ifdef EXIT_IGNORE_STACK
        !          8201:   if (! flag_omit_frame_pointer && EXIT_IGNORE_STACK
        !          8202:       && ! (DECL_INLINE (current_function_decl) && ! flag_no_inline)
        !          8203:       && ! flag_inline_functions)
        !          8204:     pending_stack_adjust = 0;
        !          8205: #endif
        !          8206: }
        !          8207: 
        !          8208: /* Pop any previously-pushed arguments that have not been popped yet.  */
        !          8209: 
        !          8210: void
        !          8211: do_pending_stack_adjust ()
        !          8212: {
        !          8213:   if (inhibit_defer_pop == 0)
        !          8214:     {
        !          8215:       if (pending_stack_adjust != 0)
        !          8216:        adjust_stack (GEN_INT (pending_stack_adjust));
        !          8217:       pending_stack_adjust = 0;
        !          8218:     }
        !          8219: }
        !          8220: 
        !          8221: /* Expand all cleanups up to OLD_CLEANUPS.
        !          8222:    Needed here, and also for language-dependent calls.  */
        !          8223: 
        !          8224: void
        !          8225: expand_cleanups_to (old_cleanups)
        !          8226:      tree old_cleanups;
        !          8227: {
        !          8228:   while (cleanups_this_call != old_cleanups)
        !          8229:     {
        !          8230:       expand_expr (TREE_VALUE (cleanups_this_call), NULL_RTX, VOIDmode, 0);
        !          8231:       cleanups_this_call = TREE_CHAIN (cleanups_this_call);
        !          8232:     }
        !          8233: }
        !          8234: 
        !          8235: /* Expand conditional expressions.  */
        !          8236: 
        !          8237: /* Generate code to evaluate EXP and jump to LABEL if the value is zero.
        !          8238:    LABEL is an rtx of code CODE_LABEL, in this function and all the
        !          8239:    functions here.  */
        !          8240: 
        !          8241: void
        !          8242: jumpifnot (exp, label)
        !          8243:      tree exp;
        !          8244:      rtx label;
        !          8245: {
        !          8246:   do_jump (exp, label, NULL_RTX);
        !          8247: }
        !          8248: 
        !          8249: /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero.  */
        !          8250: 
        !          8251: void
        !          8252: jumpif (exp, label)
        !          8253:      tree exp;
        !          8254:      rtx label;
        !          8255: {
        !          8256:   do_jump (exp, NULL_RTX, label);
        !          8257: }
        !          8258: 
        !          8259: /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
        !          8260:    the result is zero, or IF_TRUE_LABEL if the result is one.
        !          8261:    Either of IF_FALSE_LABEL and IF_TRUE_LABEL may be zero,
        !          8262:    meaning fall through in that case.
        !          8263: 
        !          8264:    do_jump always does any pending stack adjust except when it does not
        !          8265:    actually perform a jump.  An example where there is no jump
        !          8266:    is when EXP is `(foo (), 0)' and IF_FALSE_LABEL is null.
        !          8267: 
        !          8268:    This function is responsible for optimizing cases such as
        !          8269:    &&, || and comparison operators in EXP.  */
        !          8270: 
        !          8271: void
        !          8272: do_jump (exp, if_false_label, if_true_label)
        !          8273:      tree exp;
        !          8274:      rtx if_false_label, if_true_label;
        !          8275: {
        !          8276:   register enum tree_code code = TREE_CODE (exp);
        !          8277:   /* Some cases need to create a label to jump to
        !          8278:      in order to properly fall through.
        !          8279:      These cases set DROP_THROUGH_LABEL nonzero.  */
        !          8280:   rtx drop_through_label = 0;
        !          8281:   rtx temp;
        !          8282:   rtx comparison = 0;
        !          8283:   int i;
        !          8284:   tree type;
        !          8285: 
        !          8286:   emit_queue ();
        !          8287: 
        !          8288:   switch (code)
        !          8289:     {
        !          8290:     case ERROR_MARK:
        !          8291:       break;
        !          8292: 
        !          8293:     case INTEGER_CST:
        !          8294:       temp = integer_zerop (exp) ? if_false_label : if_true_label;
        !          8295:       if (temp)
        !          8296:        emit_jump (temp);
        !          8297:       break;
        !          8298: 
        !          8299: #if 0
        !          8300:       /* This is not true with #pragma weak  */
        !          8301:     case ADDR_EXPR:
        !          8302:       /* The address of something can never be zero.  */
        !          8303:       if (if_true_label)
        !          8304:        emit_jump (if_true_label);
        !          8305:       break;
        !          8306: #endif
        !          8307: 
        !          8308:     case NOP_EXPR:
        !          8309:       if (TREE_CODE (TREE_OPERAND (exp, 0)) == COMPONENT_REF
        !          8310:          || TREE_CODE (TREE_OPERAND (exp, 0)) == BIT_FIELD_REF
        !          8311:          || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_REF)
        !          8312:        goto normal;
        !          8313:     case CONVERT_EXPR:
        !          8314:       /* If we are narrowing the operand, we have to do the compare in the
        !          8315:         narrower mode.  */
        !          8316:       if ((TYPE_PRECISION (TREE_TYPE (exp))
        !          8317:           < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0)))))
        !          8318:        goto normal;
        !          8319:     case NON_LVALUE_EXPR:
        !          8320:     case REFERENCE_EXPR:
        !          8321:     case ABS_EXPR:
        !          8322:     case NEGATE_EXPR:
        !          8323:     case LROTATE_EXPR:
        !          8324:     case RROTATE_EXPR:
        !          8325:       /* These cannot change zero->non-zero or vice versa.  */
        !          8326:       do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
        !          8327:       break;
        !          8328: 
        !          8329: #if 0
        !          8330:       /* This is never less insns than evaluating the PLUS_EXPR followed by
        !          8331:         a test and can be longer if the test is eliminated.  */
        !          8332:     case PLUS_EXPR:
        !          8333:       /* Reduce to minus.  */
        !          8334:       exp = build (MINUS_EXPR, TREE_TYPE (exp),
        !          8335:                   TREE_OPERAND (exp, 0),
        !          8336:                   fold (build1 (NEGATE_EXPR, TREE_TYPE (TREE_OPERAND (exp, 1)),
        !          8337:                                 TREE_OPERAND (exp, 1))));
        !          8338:       /* Process as MINUS.  */
        !          8339: #endif
        !          8340: 
        !          8341:     case MINUS_EXPR:
        !          8342:       /* Non-zero iff operands of minus differ.  */
        !          8343:       comparison = compare (build (NE_EXPR, TREE_TYPE (exp),
        !          8344:                                   TREE_OPERAND (exp, 0),
        !          8345:                                   TREE_OPERAND (exp, 1)),
        !          8346:                            NE, NE);
        !          8347:       break;
        !          8348: 
        !          8349:     case BIT_AND_EXPR:
        !          8350:       /* If we are AND'ing with a small constant, do this comparison in the
        !          8351:         smallest type that fits.  If the machine doesn't have comparisons
        !          8352:         that small, it will be converted back to the wider comparison.
        !          8353:         This helps if we are testing the sign bit of a narrower object.
        !          8354:         combine can't do this for us because it can't know whether a
        !          8355:         ZERO_EXTRACT or a compare in a smaller mode exists, but we do.  */
        !          8356: 
        !          8357:       if (! SLOW_BYTE_ACCESS
        !          8358:          && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
        !          8359:          && TYPE_PRECISION (TREE_TYPE (exp)) <= HOST_BITS_PER_WIDE_INT
        !          8360:          && (i = floor_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))) >= 0
        !          8361:          && (type = type_for_size (i + 1, 1)) != 0
        !          8362:          && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
        !          8363:          && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
        !          8364:              != CODE_FOR_nothing))
        !          8365:        {
        !          8366:          do_jump (convert (type, exp), if_false_label, if_true_label);
        !          8367:          break;
        !          8368:        }
        !          8369:       goto normal;
        !          8370: 
        !          8371:     case TRUTH_NOT_EXPR:
        !          8372:       do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
        !          8373:       break;
        !          8374: 
        !          8375:     case TRUTH_ANDIF_EXPR:
        !          8376:       if (if_false_label == 0)
        !          8377:        if_false_label = drop_through_label = gen_label_rtx ();
        !          8378:       do_jump (TREE_OPERAND (exp, 0), if_false_label, NULL_RTX);
        !          8379:       do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
        !          8380:       break;
        !          8381: 
        !          8382:     case TRUTH_ORIF_EXPR:
        !          8383:       if (if_true_label == 0)
        !          8384:        if_true_label = drop_through_label = gen_label_rtx ();
        !          8385:       do_jump (TREE_OPERAND (exp, 0), NULL_RTX, if_true_label);
        !          8386:       do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
        !          8387:       break;
        !          8388: 
        !          8389:     case COMPOUND_EXPR:
        !          8390:       push_temp_slots ();
        !          8391:       expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
        !          8392:       free_temp_slots ();
        !          8393:       pop_temp_slots ();
        !          8394:       emit_queue ();
        !          8395:       do_pending_stack_adjust ();
        !          8396:       do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
        !          8397:       break;
        !          8398: 
        !          8399:     case COMPONENT_REF:
        !          8400:     case BIT_FIELD_REF:
        !          8401:     case ARRAY_REF:
        !          8402:       {
        !          8403:        int bitsize, bitpos, unsignedp;
        !          8404:        enum machine_mode mode;
        !          8405:        tree type;
        !          8406:        tree offset;
        !          8407:        int volatilep = 0;
        !          8408: 
        !          8409:        /* Get description of this reference.  We don't actually care
        !          8410:           about the underlying object here.  */
        !          8411:        get_inner_reference (exp, &bitsize, &bitpos, &offset,
        !          8412:                             &mode, &unsignedp, &volatilep);
        !          8413: 
        !          8414:        type = type_for_size (bitsize, unsignedp);
        !          8415:        if (! SLOW_BYTE_ACCESS
        !          8416:            && type != 0 && bitsize >= 0
        !          8417:            && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
        !          8418:            && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
        !          8419:                != CODE_FOR_nothing))
        !          8420:          {
        !          8421:            do_jump (convert (type, exp), if_false_label, if_true_label);
        !          8422:            break;
        !          8423:          }
        !          8424:        goto normal;
        !          8425:       }
        !          8426: 
        !          8427:     case COND_EXPR:
        !          8428:       /* Do (a ? 1 : 0) and (a ? 0 : 1) as special cases.  */
        !          8429:       if (integer_onep (TREE_OPERAND (exp, 1))
        !          8430:          && integer_zerop (TREE_OPERAND (exp, 2)))
        !          8431:        do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
        !          8432: 
        !          8433:       else if (integer_zerop (TREE_OPERAND (exp, 1))
        !          8434:               && integer_onep (TREE_OPERAND (exp, 2)))
        !          8435:        do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
        !          8436: 
        !          8437:       else
        !          8438:        {
        !          8439:          register rtx label1 = gen_label_rtx ();
        !          8440:          drop_through_label = gen_label_rtx ();
        !          8441:          do_jump (TREE_OPERAND (exp, 0), label1, NULL_RTX);
        !          8442:          /* Now the THEN-expression.  */
        !          8443:          do_jump (TREE_OPERAND (exp, 1),
        !          8444:                   if_false_label ? if_false_label : drop_through_label,
        !          8445:                   if_true_label ? if_true_label : drop_through_label);
        !          8446:          /* In case the do_jump just above never jumps.  */
        !          8447:          do_pending_stack_adjust ();
        !          8448:          emit_label (label1);
        !          8449:          /* Now the ELSE-expression.  */
        !          8450:          do_jump (TREE_OPERAND (exp, 2),
        !          8451:                   if_false_label ? if_false_label : drop_through_label,
        !          8452:                   if_true_label ? if_true_label : drop_through_label);
        !          8453:        }
        !          8454:       break;
        !          8455: 
        !          8456:     case EQ_EXPR:
        !          8457:       if (integer_zerop (TREE_OPERAND (exp, 1)))
        !          8458:        do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
        !          8459:       else if (((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
        !          8460:                 == MODE_INT)
        !          8461:                && 
        !          8462:                !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
        !          8463:               || GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))) == MODE_COMPLEX_FLOAT
        !          8464:               || GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))) == MODE_COMPLEX_INT)
        !          8465:        do_jump_by_parts_equality (exp, if_false_label, if_true_label);
        !          8466:       else
        !          8467:        comparison = compare (exp, EQ, EQ);
        !          8468:       break;
        !          8469: 
        !          8470:     case NE_EXPR:
        !          8471:       if (integer_zerop (TREE_OPERAND (exp, 1)))
        !          8472:        do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
        !          8473:       else if (((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
        !          8474:                 == MODE_INT)
        !          8475:                && 
        !          8476:                !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
        !          8477:               || GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))) == MODE_COMPLEX_FLOAT
        !          8478:               || GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))) == MODE_COMPLEX_INT)
        !          8479:        do_jump_by_parts_equality (exp, if_true_label, if_false_label);
        !          8480:       else
        !          8481:        comparison = compare (exp, NE, NE);
        !          8482:       break;
        !          8483: 
        !          8484:     case LT_EXPR:
        !          8485:       if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
        !          8486:           == MODE_INT)
        !          8487:          && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
        !          8488:        do_jump_by_parts_greater (exp, 1, if_false_label, if_true_label);
        !          8489:       else
        !          8490:        comparison = compare (exp, LT, LTU);
        !          8491:       break;
        !          8492: 
        !          8493:     case LE_EXPR:
        !          8494:       if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
        !          8495:           == MODE_INT)
        !          8496:          && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
        !          8497:        do_jump_by_parts_greater (exp, 0, if_true_label, if_false_label);
        !          8498:       else
        !          8499:        comparison = compare (exp, LE, LEU);
        !          8500:       break;
        !          8501: 
        !          8502:     case GT_EXPR:
        !          8503:       if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
        !          8504:           == MODE_INT)
        !          8505:          && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
        !          8506:        do_jump_by_parts_greater (exp, 0, if_false_label, if_true_label);
        !          8507:       else
        !          8508:        comparison = compare (exp, GT, GTU);
        !          8509:       break;
        !          8510: 
        !          8511:     case GE_EXPR:
        !          8512:       if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
        !          8513:           == MODE_INT)
        !          8514:          && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
        !          8515:        do_jump_by_parts_greater (exp, 1, if_true_label, if_false_label);
        !          8516:       else
        !          8517:        comparison = compare (exp, GE, GEU);
        !          8518:       break;
        !          8519: 
        !          8520:     default:
        !          8521:     normal:
        !          8522:       temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
        !          8523: #if 0
        !          8524:       /* This is not needed any more and causes poor code since it causes
        !          8525:         comparisons and tests from non-SI objects to have different code
        !          8526:         sequences.  */
        !          8527:       /* Copy to register to avoid generating bad insns by cse
        !          8528:         from (set (mem ...) (arithop))  (set (cc0) (mem ...)).  */
        !          8529:       if (!cse_not_expected && GET_CODE (temp) == MEM)
        !          8530:        temp = copy_to_reg (temp);
        !          8531: #endif
        !          8532:       do_pending_stack_adjust ();
        !          8533:       if (GET_CODE (temp) == CONST_INT)
        !          8534:        comparison = (temp == const0_rtx ? const0_rtx : const_true_rtx);
        !          8535:       else if (GET_CODE (temp) == LABEL_REF)
        !          8536:        comparison = const_true_rtx;
        !          8537:       else if (GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT
        !          8538:               && !can_compare_p (GET_MODE (temp)))
        !          8539:        /* Note swapping the labels gives us not-equal.  */
        !          8540:        do_jump_by_parts_equality_rtx (temp, if_true_label, if_false_label);
        !          8541:       else if (GET_MODE (temp) != VOIDmode)
        !          8542:        comparison = compare_from_rtx (temp, CONST0_RTX (GET_MODE (temp)),
        !          8543:                                       NE, TREE_UNSIGNED (TREE_TYPE (exp)),
        !          8544:                                       GET_MODE (temp), NULL_RTX, 0);
        !          8545:       else
        !          8546:        abort ();
        !          8547:     }
        !          8548: 
        !          8549:   /* Do any postincrements in the expression that was tested.  */
        !          8550:   emit_queue ();
        !          8551: 
        !          8552:   /* If COMPARISON is nonzero here, it is an rtx that can be substituted
        !          8553:      straight into a conditional jump instruction as the jump condition.
        !          8554:      Otherwise, all the work has been done already.  */
        !          8555: 
        !          8556:   if (comparison == const_true_rtx)
        !          8557:     {
        !          8558:       if (if_true_label)
        !          8559:        emit_jump (if_true_label);
        !          8560:     }
        !          8561:   else if (comparison == const0_rtx)
        !          8562:     {
        !          8563:       if (if_false_label)
        !          8564:        emit_jump (if_false_label);
        !          8565:     }
        !          8566:   else if (comparison)
        !          8567:     do_jump_for_compare (comparison, if_false_label, if_true_label);
        !          8568: 
        !          8569:   if (drop_through_label)
        !          8570:     {
        !          8571:       /* If do_jump produces code that might be jumped around,
        !          8572:         do any stack adjusts from that code, before the place
        !          8573:         where control merges in.  */
        !          8574:       do_pending_stack_adjust ();
        !          8575:       emit_label (drop_through_label);
        !          8576:     }
        !          8577: }
        !          8578: 
        !          8579: /* Given a comparison expression EXP for values too wide to be compared
        !          8580:    with one insn, test the comparison and jump to the appropriate label.
        !          8581:    The code of EXP is ignored; we always test GT if SWAP is 0,
        !          8582:    and LT if SWAP is 1.  */
        !          8583: 
        !          8584: static void
        !          8585: do_jump_by_parts_greater (exp, swap, if_false_label, if_true_label)
        !          8586:      tree exp;
        !          8587:      int swap;
        !          8588:      rtx if_false_label, if_true_label;
        !          8589: {
        !          8590:   rtx op0 = expand_expr (TREE_OPERAND (exp, swap), NULL_RTX, VOIDmode, 0);
        !          8591:   rtx op1 = expand_expr (TREE_OPERAND (exp, !swap), NULL_RTX, VOIDmode, 0);
        !          8592:   enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
        !          8593:   int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
        !          8594:   rtx drop_through_label = 0;
        !          8595:   int unsignedp = TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)));
        !          8596:   int i;
        !          8597: 
        !          8598:   if (! if_true_label || ! if_false_label)
        !          8599:     drop_through_label = gen_label_rtx ();
        !          8600:   if (! if_true_label)
        !          8601:     if_true_label = drop_through_label;
        !          8602:   if (! if_false_label)
        !          8603:     if_false_label = drop_through_label;
        !          8604: 
        !          8605:   /* Compare a word at a time, high order first.  */
        !          8606:   for (i = 0; i < nwords; i++)
        !          8607:     {
        !          8608:       rtx comp;
        !          8609:       rtx op0_word, op1_word;
        !          8610: 
        !          8611:       if (WORDS_BIG_ENDIAN)
        !          8612:        {
        !          8613:          op0_word = operand_subword_force (op0, i, mode);
        !          8614:          op1_word = operand_subword_force (op1, i, mode);
        !          8615:        }
        !          8616:       else
        !          8617:        {
        !          8618:          op0_word = operand_subword_force (op0, nwords - 1 - i, mode);
        !          8619:          op1_word = operand_subword_force (op1, nwords - 1 - i, mode);
        !          8620:        }
        !          8621: 
        !          8622:       /* All but high-order word must be compared as unsigned.  */
        !          8623:       comp = compare_from_rtx (op0_word, op1_word,
        !          8624:                               (unsignedp || i > 0) ? GTU : GT,
        !          8625:                               unsignedp, word_mode, NULL_RTX, 0);
        !          8626:       if (comp == const_true_rtx)
        !          8627:        emit_jump (if_true_label);
        !          8628:       else if (comp != const0_rtx)
        !          8629:        do_jump_for_compare (comp, NULL_RTX, if_true_label);
        !          8630: 
        !          8631:       /* Consider lower words only if these are equal.  */
        !          8632:       comp = compare_from_rtx (op0_word, op1_word, NE, unsignedp, word_mode,
        !          8633:                               NULL_RTX, 0);
        !          8634:       if (comp == const_true_rtx)
        !          8635:        emit_jump (if_false_label);
        !          8636:       else if (comp != const0_rtx)
        !          8637:        do_jump_for_compare (comp, NULL_RTX, if_false_label);
        !          8638:     }
        !          8639: 
        !          8640:   if (if_false_label)
        !          8641:     emit_jump (if_false_label);
        !          8642:   if (drop_through_label)
        !          8643:     emit_label (drop_through_label);
        !          8644: }
        !          8645: 
        !          8646: /* Compare OP0 with OP1, word at a time, in mode MODE.
        !          8647:    UNSIGNEDP says to do unsigned comparison.
        !          8648:    Jump to IF_TRUE_LABEL if OP0 is greater, IF_FALSE_LABEL otherwise.  */
        !          8649: 
        !          8650: static void
        !          8651: do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label, if_true_label)
        !          8652:      enum machine_mode mode;
        !          8653:      int unsignedp;
        !          8654:      rtx op0, op1;
        !          8655:      rtx if_false_label, if_true_label;
        !          8656: {
        !          8657:   int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
        !          8658:   rtx drop_through_label = 0;
        !          8659:   int i;
        !          8660: 
        !          8661:   if (! if_true_label || ! if_false_label)
        !          8662:     drop_through_label = gen_label_rtx ();
        !          8663:   if (! if_true_label)
        !          8664:     if_true_label = drop_through_label;
        !          8665:   if (! if_false_label)
        !          8666:     if_false_label = drop_through_label;
        !          8667: 
        !          8668:   /* Compare a word at a time, high order first.  */
        !          8669:   for (i = 0; i < nwords; i++)
        !          8670:     {
        !          8671:       rtx comp;
        !          8672:       rtx op0_word, op1_word;
        !          8673: 
        !          8674:       if (WORDS_BIG_ENDIAN)
        !          8675:        {
        !          8676:          op0_word = operand_subword_force (op0, i, mode);
        !          8677:          op1_word = operand_subword_force (op1, i, mode);
        !          8678:        }
        !          8679:       else
        !          8680:        {
        !          8681:          op0_word = operand_subword_force (op0, nwords - 1 - i, mode);
        !          8682:          op1_word = operand_subword_force (op1, nwords - 1 - i, mode);
        !          8683:        }
        !          8684: 
        !          8685:       /* All but high-order word must be compared as unsigned.  */
        !          8686:       comp = compare_from_rtx (op0_word, op1_word,
        !          8687:                               (unsignedp || i > 0) ? GTU : GT,
        !          8688:                               unsignedp, word_mode, NULL_RTX, 0);
        !          8689:       if (comp == const_true_rtx)
        !          8690:        emit_jump (if_true_label);
        !          8691:       else if (comp != const0_rtx)
        !          8692:        do_jump_for_compare (comp, NULL_RTX, if_true_label);
        !          8693: 
        !          8694:       /* Consider lower words only if these are equal.  */
        !          8695:       comp = compare_from_rtx (op0_word, op1_word, NE, unsignedp, word_mode,
        !          8696:                               NULL_RTX, 0);
        !          8697:       if (comp == const_true_rtx)
        !          8698:        emit_jump (if_false_label);
        !          8699:       else if (comp != const0_rtx)
        !          8700:        do_jump_for_compare (comp, NULL_RTX, if_false_label);
        !          8701:     }
        !          8702: 
        !          8703:   if (if_false_label)
        !          8704:     emit_jump (if_false_label);
        !          8705:   if (drop_through_label)
        !          8706:     emit_label (drop_through_label);
        !          8707: }
        !          8708: 
        !          8709: /* Given an EQ_EXPR expression EXP for values too wide to be compared
        !          8710:    with one insn, test the comparison and jump to the appropriate label.  */
        !          8711: 
        !          8712: static void
        !          8713: do_jump_by_parts_equality (exp, if_false_label, if_true_label)
        !          8714:      tree exp;
        !          8715:      rtx if_false_label, if_true_label;
        !          8716: {
        !          8717:   rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
        !          8718:   rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
        !          8719:   enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
        !          8720:   int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
        !          8721:   int i;
        !          8722:   rtx drop_through_label = 0;
        !          8723: 
        !          8724:   if (! if_false_label)
        !          8725:     drop_through_label = if_false_label = gen_label_rtx ();
        !          8726: 
        !          8727:   for (i = 0; i < nwords; i++)
        !          8728:     {
        !          8729:       rtx comp = compare_from_rtx (operand_subword_force (op0, i, mode),
        !          8730:                                   operand_subword_force (op1, i, mode),
        !          8731:                                   EQ, TREE_UNSIGNED (TREE_TYPE (exp)),
        !          8732:                                   word_mode, NULL_RTX, 0);
        !          8733:       if (comp == const_true_rtx)
        !          8734:        emit_jump (if_false_label);
        !          8735:       else if (comp != const0_rtx)
        !          8736:        do_jump_for_compare (comp, if_false_label, NULL_RTX);
        !          8737:     }
        !          8738: 
        !          8739:   if (if_true_label)
        !          8740:     emit_jump (if_true_label);
        !          8741:   if (drop_through_label)
        !          8742:     emit_label (drop_through_label);
        !          8743: }
        !          8744: 
        !          8745: /* Jump according to whether OP0 is 0.
        !          8746:    We assume that OP0 has an integer mode that is too wide
        !          8747:    for the available compare insns.  */
        !          8748: 
        !          8749: static void
        !          8750: do_jump_by_parts_equality_rtx (op0, if_false_label, if_true_label)
        !          8751:      rtx op0;
        !          8752:      rtx if_false_label, if_true_label;
        !          8753: {
        !          8754:   int nwords = GET_MODE_SIZE (GET_MODE (op0)) / UNITS_PER_WORD;
        !          8755:   int i;
        !          8756:   rtx drop_through_label = 0;
        !          8757: 
        !          8758:   if (! if_false_label)
        !          8759:     drop_through_label = if_false_label = gen_label_rtx ();
        !          8760: 
        !          8761:   for (i = 0; i < nwords; i++)
        !          8762:     {
        !          8763:       rtx comp = compare_from_rtx (operand_subword_force (op0, i,
        !          8764:                                                          GET_MODE (op0)),
        !          8765:                                   const0_rtx, EQ, 1, word_mode, NULL_RTX, 0);
        !          8766:       if (comp == const_true_rtx)
        !          8767:        emit_jump (if_false_label);
        !          8768:       else if (comp != const0_rtx)
        !          8769:        do_jump_for_compare (comp, if_false_label, NULL_RTX);
        !          8770:     }
        !          8771: 
        !          8772:   if (if_true_label)
        !          8773:     emit_jump (if_true_label);
        !          8774:   if (drop_through_label)
        !          8775:     emit_label (drop_through_label);
        !          8776: }
        !          8777: 
        !          8778: /* Given a comparison expression in rtl form, output conditional branches to
        !          8779:    IF_TRUE_LABEL, IF_FALSE_LABEL, or both.  */
        !          8780: 
        !          8781: static void
        !          8782: do_jump_for_compare (comparison, if_false_label, if_true_label)
        !          8783:      rtx comparison, if_false_label, if_true_label;
        !          8784: {
        !          8785:   if (if_true_label)
        !          8786:     {
        !          8787:       if (bcc_gen_fctn[(int) GET_CODE (comparison)] != 0)
        !          8788:        emit_jump_insn ((*bcc_gen_fctn[(int) GET_CODE (comparison)]) (if_true_label));
        !          8789:       else
        !          8790:        abort ();
        !          8791: 
        !          8792:       if (if_false_label)
        !          8793:        emit_jump (if_false_label);
        !          8794:     }
        !          8795:   else if (if_false_label)
        !          8796:     {
        !          8797:       rtx insn;
        !          8798:       rtx prev = get_last_insn ();
        !          8799:       rtx branch = 0;
        !          8800: 
        !          8801:       if (prev != 0)
        !          8802:        prev = PREV_INSN (prev);
        !          8803: 
        !          8804:       /* Output the branch with the opposite condition.  Then try to invert
        !          8805:         what is generated.  If more than one insn is a branch, or if the
        !          8806:         branch is not the last insn written, abort. If we can't invert
        !          8807:         the branch, emit make a true label, redirect this jump to that,
        !          8808:         emit a jump to the false label and define the true label.  */
        !          8809: 
        !          8810:       if (bcc_gen_fctn[(int) GET_CODE (comparison)] != 0)
        !          8811:        emit_jump_insn ((*bcc_gen_fctn[(int) GET_CODE (comparison)]) (if_false_label));
        !          8812:       else
        !          8813:        abort ();
        !          8814: 
        !          8815:       /* Here we get the insn before what was just emitted.
        !          8816:         On some machines, emitting the branch can discard
        !          8817:         the previous compare insn and emit a replacement.  */
        !          8818:       if (prev == 0)
        !          8819:        /* If there's only one preceding insn...  */
        !          8820:        insn = get_insns ();
        !          8821:       else
        !          8822:        insn = NEXT_INSN (prev);
        !          8823: 
        !          8824:       for (insn = NEXT_INSN (insn); insn; insn = NEXT_INSN (insn))
        !          8825:        if (GET_CODE (insn) == JUMP_INSN)
        !          8826:          {
        !          8827:            if (branch)
        !          8828:              abort ();
        !          8829:            branch = insn;
        !          8830:          }
        !          8831: 
        !          8832:       if (branch != get_last_insn ())
        !          8833:        abort ();
        !          8834: 
        !          8835:       if (! invert_jump (branch, if_false_label))
        !          8836:        {
        !          8837:          if_true_label = gen_label_rtx ();
        !          8838:          redirect_jump (branch, if_true_label);
        !          8839:          emit_jump (if_false_label);
        !          8840:          emit_label (if_true_label);
        !          8841:        }
        !          8842:     }
        !          8843: }
        !          8844: 
        !          8845: /* Generate code for a comparison expression EXP
        !          8846:    (including code to compute the values to be compared)
        !          8847:    and set (CC0) according to the result.
        !          8848:    SIGNED_CODE should be the rtx operation for this comparison for
        !          8849:    signed data; UNSIGNED_CODE, likewise for use if data is unsigned.
        !          8850: 
        !          8851:    We force a stack adjustment unless there are currently
        !          8852:    things pushed on the stack that aren't yet used.  */
        !          8853: 
        !          8854: static rtx
        !          8855: compare (exp, signed_code, unsigned_code)
        !          8856:      register tree exp;
        !          8857:      enum rtx_code signed_code, unsigned_code;
        !          8858: {
        !          8859:   register rtx op0
        !          8860:     = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
        !          8861:   register rtx op1
        !          8862:     = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
        !          8863:   register tree type = TREE_TYPE (TREE_OPERAND (exp, 0));
        !          8864:   register enum machine_mode mode = TYPE_MODE (type);
        !          8865:   int unsignedp = TREE_UNSIGNED (type);
        !          8866:   enum rtx_code code = unsignedp ? unsigned_code : signed_code;
        !          8867: 
        !          8868:   return compare_from_rtx (op0, op1, code, unsignedp, mode,
        !          8869:                           ((mode == BLKmode)
        !          8870:                            ? expr_size (TREE_OPERAND (exp, 0)) : NULL_RTX),
        !          8871:                           TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
        !          8872: }
        !          8873: 
        !          8874: /* Like compare but expects the values to compare as two rtx's.
        !          8875:    The decision as to signed or unsigned comparison must be made by the caller.
        !          8876: 
        !          8877:    If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
        !          8878:    compared.
        !          8879: 
        !          8880:    If ALIGN is non-zero, it is the alignment of this type; if zero, the
        !          8881:    size of MODE should be used.  */
        !          8882: 
        !          8883: rtx
        !          8884: compare_from_rtx (op0, op1, code, unsignedp, mode, size, align)
        !          8885:      register rtx op0, op1;
        !          8886:      enum rtx_code code;
        !          8887:      int unsignedp;
        !          8888:      enum machine_mode mode;
        !          8889:      rtx size;
        !          8890:      int align;
        !          8891: {
        !          8892:   rtx tem;
        !          8893: 
        !          8894:   /* If one operand is constant, make it the second one.  Only do this
        !          8895:      if the other operand is not constant as well.  */
        !          8896: 
        !          8897:   if ((CONSTANT_P (op0) && ! CONSTANT_P (op1))
        !          8898:       || (GET_CODE (op0) == CONST_INT && GET_CODE (op1) != CONST_INT))
        !          8899:     {
        !          8900:       tem = op0;
        !          8901:       op0 = op1;
        !          8902:       op1 = tem;
        !          8903:       code = swap_condition (code);
        !          8904:     }
        !          8905: 
        !          8906:   if (flag_force_mem)
        !          8907:     {
        !          8908:       op0 = force_not_mem (op0);
        !          8909:       op1 = force_not_mem (op1);
        !          8910:     }
        !          8911: 
        !          8912:   do_pending_stack_adjust ();
        !          8913: 
        !          8914:   if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT
        !          8915:       && (tem = simplify_relational_operation (code, mode, op0, op1)) != 0)
        !          8916:     return tem;
        !          8917: 
        !          8918: #if 0
        !          8919:   /* There's no need to do this now that combine.c can eliminate lots of
        !          8920:      sign extensions.  This can be less efficient in certain cases on other
        !          8921:      machines. */
        !          8922: 
        !          8923:   /* If this is a signed equality comparison, we can do it as an
        !          8924:      unsigned comparison since zero-extension is cheaper than sign
        !          8925:      extension and comparisons with zero are done as unsigned.  This is
        !          8926:      the case even on machines that can do fast sign extension, since
        !          8927:      zero-extension is easier to combine with other operations than
        !          8928:      sign-extension is.  If we are comparing against a constant, we must
        !          8929:      convert it to what it would look like unsigned.  */
        !          8930:   if ((code == EQ || code == NE) && ! unsignedp
        !          8931:       && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT)
        !          8932:     {
        !          8933:       if (GET_CODE (op1) == CONST_INT
        !          8934:          && (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0))) != INTVAL (op1))
        !          8935:        op1 = GEN_INT (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0)));
        !          8936:       unsignedp = 1;
        !          8937:     }
        !          8938: #endif
        !          8939:        
        !          8940:   emit_cmp_insn (op0, op1, code, size, mode, unsignedp, align);
        !          8941: 
        !          8942:   return gen_rtx (code, VOIDmode, cc0_rtx, const0_rtx);
        !          8943: }
        !          8944: 
        !          8945: /* Generate code to calculate EXP using a store-flag instruction
        !          8946:    and return an rtx for the result.  EXP is either a comparison
        !          8947:    or a TRUTH_NOT_EXPR whose operand is a comparison.
        !          8948: 
        !          8949:    If TARGET is nonzero, store the result there if convenient.
        !          8950: 
        !          8951:    If ONLY_CHEAP is non-zero, only do this if it is likely to be very
        !          8952:    cheap.
        !          8953: 
        !          8954:    Return zero if there is no suitable set-flag instruction
        !          8955:    available on this machine.
        !          8956: 
        !          8957:    Once expand_expr has been called on the arguments of the comparison,
        !          8958:    we are committed to doing the store flag, since it is not safe to
        !          8959:    re-evaluate the expression.  We emit the store-flag insn by calling
        !          8960:    emit_store_flag, but only expand the arguments if we have a reason
        !          8961:    to believe that emit_store_flag will be successful.  If we think that
        !          8962:    it will, but it isn't, we have to simulate the store-flag with a
        !          8963:    set/jump/set sequence.  */
        !          8964: 
        !          8965: static rtx
        !          8966: do_store_flag (exp, target, mode, only_cheap)
        !          8967:      tree exp;
        !          8968:      rtx target;
        !          8969:      enum machine_mode mode;
        !          8970:      int only_cheap;
        !          8971: {
        !          8972:   enum rtx_code code;
        !          8973:   tree arg0, arg1, type;
        !          8974:   tree tem;
        !          8975:   enum machine_mode operand_mode;
        !          8976:   int invert = 0;
        !          8977:   int unsignedp;
        !          8978:   rtx op0, op1;
        !          8979:   enum insn_code icode;
        !          8980:   rtx subtarget = target;
        !          8981:   rtx result, label, pattern, jump_pat;
        !          8982: 
        !          8983:   /* If this is a TRUTH_NOT_EXPR, set a flag indicating we must invert the
        !          8984:      result at the end.  We can't simply invert the test since it would
        !          8985:      have already been inverted if it were valid.  This case occurs for
        !          8986:      some floating-point comparisons.  */
        !          8987: 
        !          8988:   if (TREE_CODE (exp) == TRUTH_NOT_EXPR)
        !          8989:     invert = 1, exp = TREE_OPERAND (exp, 0);
        !          8990: 
        !          8991:   arg0 = TREE_OPERAND (exp, 0);
        !          8992:   arg1 = TREE_OPERAND (exp, 1);
        !          8993:   type = TREE_TYPE (arg0);
        !          8994:   operand_mode = TYPE_MODE (type);
        !          8995:   unsignedp = TREE_UNSIGNED (type);
        !          8996: 
        !          8997:   /* We won't bother with BLKmode store-flag operations because it would mean
        !          8998:      passing a lot of information to emit_store_flag.  */
        !          8999:   if (operand_mode == BLKmode)
        !          9000:     return 0;
        !          9001: 
        !          9002:   STRIP_NOPS (arg0);
        !          9003:   STRIP_NOPS (arg1);
        !          9004: 
        !          9005:   /* Get the rtx comparison code to use.  We know that EXP is a comparison
        !          9006:      operation of some type.  Some comparisons against 1 and -1 can be
        !          9007:      converted to comparisons with zero.  Do so here so that the tests
        !          9008:      below will be aware that we have a comparison with zero.   These
        !          9009:      tests will not catch constants in the first operand, but constants
        !          9010:      are rarely passed as the first operand.  */
        !          9011: 
        !          9012:   switch (TREE_CODE (exp))
        !          9013:     {
        !          9014:     case EQ_EXPR:
        !          9015:       code = EQ;
        !          9016:       break;
        !          9017:     case NE_EXPR:
        !          9018:       code = NE;
        !          9019:       break;
        !          9020:     case LT_EXPR:
        !          9021:       if (integer_onep (arg1))
        !          9022:        arg1 = integer_zero_node, code = unsignedp ? LEU : LE;
        !          9023:       else
        !          9024:        code = unsignedp ? LTU : LT;
        !          9025:       break;
        !          9026:     case LE_EXPR:
        !          9027:       if (! unsignedp && integer_all_onesp (arg1))
        !          9028:        arg1 = integer_zero_node, code = LT;
        !          9029:       else
        !          9030:        code = unsignedp ? LEU : LE;
        !          9031:       break;
        !          9032:     case GT_EXPR:
        !          9033:       if (! unsignedp && integer_all_onesp (arg1))
        !          9034:        arg1 = integer_zero_node, code = GE;
        !          9035:       else
        !          9036:        code = unsignedp ? GTU : GT;
        !          9037:       break;
        !          9038:     case GE_EXPR:
        !          9039:       if (integer_onep (arg1))
        !          9040:        arg1 = integer_zero_node, code = unsignedp ? GTU : GT;
        !          9041:       else
        !          9042:        code = unsignedp ? GEU : GE;
        !          9043:       break;
        !          9044:     default:
        !          9045:       abort ();
        !          9046:     }
        !          9047: 
        !          9048:   /* Put a constant second.  */
        !          9049:   if (TREE_CODE (arg0) == REAL_CST || TREE_CODE (arg0) == INTEGER_CST)
        !          9050:     {
        !          9051:       tem = arg0; arg0 = arg1; arg1 = tem;
        !          9052:       code = swap_condition (code);
        !          9053:     }
        !          9054: 
        !          9055:   /* If this is an equality or inequality test of a single bit, we can
        !          9056:      do this by shifting the bit being tested to the low-order bit and
        !          9057:      masking the result with the constant 1.  If the condition was EQ,
        !          9058:      we xor it with 1.  This does not require an scc insn and is faster
        !          9059:      than an scc insn even if we have it.  */
        !          9060: 
        !          9061:   if ((code == NE || code == EQ)
        !          9062:       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
        !          9063:       && integer_pow2p (TREE_OPERAND (arg0, 1))
        !          9064:       && TYPE_PRECISION (type) <= HOST_BITS_PER_WIDE_INT)
        !          9065:     {
        !          9066:       tree inner = TREE_OPERAND (arg0, 0);
        !          9067:       int bitnum = exact_log2 (INTVAL (expand_expr (TREE_OPERAND (arg0, 1),
        !          9068:                                                    NULL_RTX, VOIDmode, 0)));
        !          9069:       int ops_unsignedp;
        !          9070: 
        !          9071:       /* If INNER is a right shift of a constant and it plus BITNUM does
        !          9072:         not overflow, adjust BITNUM and INNER.  */
        !          9073: 
        !          9074:       if (TREE_CODE (inner) == RSHIFT_EXPR
        !          9075:          && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
        !          9076:          && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
        !          9077:          && (bitnum + TREE_INT_CST_LOW (TREE_OPERAND (inner, 1))
        !          9078:              < TYPE_PRECISION (type)))
        !          9079:        {
        !          9080:          bitnum +=TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
        !          9081:          inner = TREE_OPERAND (inner, 0);
        !          9082:        }
        !          9083: 
        !          9084:       /* If we are going to be able to omit the AND below, we must do our
        !          9085:         operations as unsigned.  If we must use the AND, we have a choice.
        !          9086:         Normally unsigned is faster, but for some machines signed is.  */
        !          9087:       ops_unsignedp = (bitnum == TYPE_PRECISION (type) - 1 ? 1
        !          9088: #ifdef LOAD_EXTEND_OP
        !          9089:                       : (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND ? 0 : 1)
        !          9090: #else
        !          9091:                       : 1
        !          9092: #endif
        !          9093:                       );
        !          9094: 
        !          9095:       if (subtarget == 0 || GET_CODE (subtarget) != REG
        !          9096:          || GET_MODE (subtarget) != operand_mode
        !          9097:          || ! safe_from_p (subtarget, inner))
        !          9098:        subtarget = 0;
        !          9099: 
        !          9100:       op0 = expand_expr (inner, subtarget, VOIDmode, 0);
        !          9101: 
        !          9102:       if (bitnum != 0)
        !          9103:        op0 = expand_shift (RSHIFT_EXPR, GET_MODE (op0), op0,
        !          9104:                            size_int (bitnum), subtarget, ops_unsignedp);
        !          9105: 
        !          9106:       if (GET_MODE (op0) != mode)
        !          9107:        op0 = convert_to_mode (mode, op0, ops_unsignedp);
        !          9108: 
        !          9109:       if ((code == EQ && ! invert) || (code == NE && invert))
        !          9110:        op0 = expand_binop (mode, xor_optab, op0, const1_rtx, subtarget,
        !          9111:                            ops_unsignedp, OPTAB_LIB_WIDEN);
        !          9112: 
        !          9113:       /* Put the AND last so it can combine with more things.  */
        !          9114:       if (bitnum != TYPE_PRECISION (type) - 1)
        !          9115:        op0 = expand_and (op0, const1_rtx, subtarget);
        !          9116: 
        !          9117:       return op0;
        !          9118:     }
        !          9119: 
        !          9120:   /* Now see if we are likely to be able to do this.  Return if not.  */
        !          9121:   if (! can_compare_p (operand_mode))
        !          9122:     return 0;
        !          9123:   icode = setcc_gen_code[(int) code];
        !          9124:   if (icode == CODE_FOR_nothing
        !          9125:       || (only_cheap && insn_operand_mode[(int) icode][0] != mode))
        !          9126:     {
        !          9127:       /* We can only do this if it is one of the special cases that
        !          9128:         can be handled without an scc insn.  */
        !          9129:       if ((code == LT && integer_zerop (arg1))
        !          9130:          || (! only_cheap && code == GE && integer_zerop (arg1)))
        !          9131:        ;
        !          9132:       else if (BRANCH_COST >= 0
        !          9133:               && ! only_cheap && (code == NE || code == EQ)
        !          9134:               && TREE_CODE (type) != REAL_TYPE
        !          9135:               && ((abs_optab->handlers[(int) operand_mode].insn_code
        !          9136:                    != CODE_FOR_nothing)
        !          9137:                   || (ffs_optab->handlers[(int) operand_mode].insn_code
        !          9138:                       != CODE_FOR_nothing)))
        !          9139:        ;
        !          9140:       else
        !          9141:        return 0;
        !          9142:     }
        !          9143:       
        !          9144:   preexpand_calls (exp);
        !          9145:   if (subtarget == 0 || GET_CODE (subtarget) != REG
        !          9146:       || GET_MODE (subtarget) != operand_mode
        !          9147:       || ! safe_from_p (subtarget, arg1))
        !          9148:     subtarget = 0;
        !          9149: 
        !          9150:   op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
        !          9151:   op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
        !          9152: 
        !          9153:   if (target == 0)
        !          9154:     target = gen_reg_rtx (mode);
        !          9155: 
        !          9156:   /* Pass copies of OP0 and OP1 in case they contain a QUEUED.  This is safe
        !          9157:      because, if the emit_store_flag does anything it will succeed and
        !          9158:      OP0 and OP1 will not be used subsequently.  */
        !          9159: 
        !          9160:   result = emit_store_flag (target, code,
        !          9161:                            queued_subexp_p (op0) ? copy_rtx (op0) : op0,
        !          9162:                            queued_subexp_p (op1) ? copy_rtx (op1) : op1,
        !          9163:                            operand_mode, unsignedp, 1);
        !          9164: 
        !          9165:   if (result)
        !          9166:     {
        !          9167:       if (invert)
        !          9168:        result = expand_binop (mode, xor_optab, result, const1_rtx,
        !          9169:                               result, 0, OPTAB_LIB_WIDEN);
        !          9170:       return result;
        !          9171:     }
        !          9172: 
        !          9173:   /* If this failed, we have to do this with set/compare/jump/set code.  */
        !          9174:   if (target == 0 || GET_CODE (target) != REG
        !          9175:       || reg_mentioned_p (target, op0) || reg_mentioned_p (target, op1))
        !          9176:     target = gen_reg_rtx (GET_MODE (target));
        !          9177: 
        !          9178:   emit_move_insn (target, invert ? const0_rtx : const1_rtx);
        !          9179:   result = compare_from_rtx (op0, op1, code, unsignedp,
        !          9180:                             operand_mode, NULL_RTX, 0);
        !          9181:   if (GET_CODE (result) == CONST_INT)
        !          9182:     return (((result == const0_rtx && ! invert)
        !          9183:             || (result != const0_rtx && invert))
        !          9184:            ? const0_rtx : const1_rtx);
        !          9185: 
        !          9186:   label = gen_label_rtx ();
        !          9187:   if (bcc_gen_fctn[(int) code] == 0)
        !          9188:     abort ();
        !          9189: 
        !          9190:   emit_jump_insn ((*bcc_gen_fctn[(int) code]) (label));
        !          9191:   emit_move_insn (target, invert ? const1_rtx : const0_rtx);
        !          9192:   emit_label (label);
        !          9193: 
        !          9194:   return target;
        !          9195: }
        !          9196: 
        !          9197: /* Generate a tablejump instruction (used for switch statements).  */
        !          9198: 
        !          9199: #ifdef HAVE_tablejump
        !          9200: 
        !          9201: /* INDEX is the value being switched on, with the lowest value
        !          9202:    in the table already subtracted.
        !          9203:    MODE is its expected mode (needed if INDEX is constant).
        !          9204:    RANGE is the length of the jump table.
        !          9205:    TABLE_LABEL is a CODE_LABEL rtx for the table itself.
        !          9206: 
        !          9207:    DEFAULT_LABEL is a CODE_LABEL rtx to jump to if the
        !          9208:    index value is out of range.  */
        !          9209: 
        !          9210: void
        !          9211: do_tablejump (index, mode, range, table_label, default_label)
        !          9212:      rtx index, range, table_label, default_label;
        !          9213:      enum machine_mode mode;
        !          9214: {
        !          9215:   register rtx temp, vector;
        !          9216: 
        !          9217:   /* Do an unsigned comparison (in the proper mode) between the index
        !          9218:      expression and the value which represents the length of the range.
        !          9219:      Since we just finished subtracting the lower bound of the range
        !          9220:      from the index expression, this comparison allows us to simultaneously
        !          9221:      check that the original index expression value is both greater than
        !          9222:      or equal to the minimum value of the range and less than or equal to
        !          9223:      the maximum value of the range.  */
        !          9224: 
        !          9225:   emit_cmp_insn (range, index, LTU, NULL_RTX, mode, 1, 0);
        !          9226:   emit_jump_insn (gen_bltu (default_label));
        !          9227: 
        !          9228:   /* If index is in range, it must fit in Pmode.
        !          9229:      Convert to Pmode so we can index with it.  */
        !          9230:   if (mode != Pmode)
        !          9231:     index = convert_to_mode (Pmode, index, 1);
        !          9232: 
        !          9233:   /* Don't let a MEM slip thru, because then INDEX that comes
        !          9234:      out of PIC_CASE_VECTOR_ADDRESS won't be a valid address,
        !          9235:      and break_out_memory_refs will go to work on it and mess it up.  */
        !          9236: #ifdef PIC_CASE_VECTOR_ADDRESS
        !          9237:   if (flag_pic && GET_CODE (index) != REG)
        !          9238:     index = copy_to_mode_reg (Pmode, index);
        !          9239: #endif
        !          9240: 
        !          9241:   /* If flag_force_addr were to affect this address
        !          9242:      it could interfere with the tricky assumptions made
        !          9243:      about addresses that contain label-refs,
        !          9244:      which may be valid only very near the tablejump itself.  */
        !          9245:   /* ??? The only correct use of CASE_VECTOR_MODE is the one inside the
        !          9246:      GET_MODE_SIZE, because this indicates how large insns are.  The other
        !          9247:      uses should all be Pmode, because they are addresses.  This code
        !          9248:      could fail if addresses and insns are not the same size.  */
        !          9249:   index = gen_rtx (PLUS, Pmode,
        !          9250:                   gen_rtx (MULT, Pmode, index,
        !          9251:                            GEN_INT (GET_MODE_SIZE (CASE_VECTOR_MODE))),
        !          9252:                   gen_rtx (LABEL_REF, Pmode, table_label));
        !          9253: #ifdef PIC_CASE_VECTOR_ADDRESS
        !          9254:   if (flag_pic)
        !          9255:     index = PIC_CASE_VECTOR_ADDRESS (index);
        !          9256:   else
        !          9257: #endif
        !          9258:     index = memory_address_noforce (CASE_VECTOR_MODE, index);
        !          9259:   temp = gen_reg_rtx (CASE_VECTOR_MODE);
        !          9260:   vector = gen_rtx (MEM, CASE_VECTOR_MODE, index);
        !          9261:   RTX_UNCHANGING_P (vector) = 1;
        !          9262:   convert_move (temp, vector, 0);
        !          9263: 
        !          9264:   emit_jump_insn (gen_tablejump (temp, table_label));
        !          9265: 
        !          9266: #ifndef CASE_VECTOR_PC_RELATIVE
        !          9267:   /* If we are generating PIC code or if the table is PC-relative, the
        !          9268:      table and JUMP_INSN must be adjacent, so don't output a BARRIER.  */
        !          9269:   if (! flag_pic)
        !          9270:     emit_barrier ();
        !          9271: #endif
        !          9272: }
        !          9273: 
        !          9274: #endif /* HAVE_tablejump */
        !          9275: 
        !          9276: 
        !          9277: /* Emit a suitable bytecode to load a value from memory, assuming a pointer
        !          9278:    to that value is on the top of the stack. The resulting type is TYPE, and
        !          9279:    the source declaration is DECL. */
        !          9280: 
        !          9281: void
        !          9282: bc_load_memory (type, decl)
        !          9283:      tree type, decl;
        !          9284: {
        !          9285:   enum bytecode_opcode opcode;
        !          9286:   
        !          9287:   
        !          9288:   /* Bit fields are special.  We only know about signed and
        !          9289:      unsigned ints, and enums.  The latter are treated as
        !          9290:      signed integers. */
        !          9291:   
        !          9292:   if (DECL_BIT_FIELD (decl))
        !          9293:     if (TREE_CODE (type) == ENUMERAL_TYPE
        !          9294:        || TREE_CODE (type) == INTEGER_TYPE)
        !          9295:       opcode = TREE_UNSIGNED (type) ? zxloadBI : sxloadBI;
        !          9296:     else
        !          9297:       abort ();
        !          9298:   else
        !          9299:     /* See corresponding comment in bc_store_memory(). */
        !          9300:     if (TYPE_MODE (type) == BLKmode
        !          9301:        || TYPE_MODE (type) == VOIDmode)
        !          9302:       return;
        !          9303:     else
        !          9304:       opcode = mode_to_load_map [(int) TYPE_MODE (type)];
        !          9305: 
        !          9306:   if (opcode == neverneverland)
        !          9307:     abort ();
        !          9308:   
        !          9309:   bc_emit_bytecode (opcode);
        !          9310:   
        !          9311: #ifdef DEBUG_PRINT_CODE
        !          9312:   fputc ('\n', stderr);
        !          9313: #endif
        !          9314: }
        !          9315: 
        !          9316: 
        !          9317: /* Store the contents of the second stack slot to the address in the
        !          9318:    top stack slot.  DECL is the declaration of the destination and is used
        !          9319:    to determine whether we're dealing with a bitfield. */
        !          9320: 
        !          9321: void
        !          9322: bc_store_memory (type, decl)
        !          9323:      tree type, decl;
        !          9324: {
        !          9325:   enum bytecode_opcode opcode;
        !          9326:   
        !          9327:   
        !          9328:   if (DECL_BIT_FIELD (decl))
        !          9329:     {
        !          9330:       if (TREE_CODE (type) == ENUMERAL_TYPE
        !          9331:          || TREE_CODE (type) == INTEGER_TYPE)
        !          9332:        opcode = sstoreBI;
        !          9333:       else
        !          9334:        abort ();
        !          9335:     }
        !          9336:   else
        !          9337:     if (TYPE_MODE (type) == BLKmode)
        !          9338:       {
        !          9339:        /* Copy structure.  This expands to a block copy instruction, storeBLK.
        !          9340:           In addition to the arguments expected by the other store instructions,
        !          9341:           it also expects a type size (SImode) on top of the stack, which is the
        !          9342:           structure size in size units (usually bytes).  The two first arguments
        !          9343:           are already on the stack; so we just put the size on level 1.  For some
        !          9344:           other languages, the size may be variable, this is why we don't encode
        !          9345:           it as a storeBLK literal, but rather treat it as a full-fledged expression. */
        !          9346:        
        !          9347:        bc_expand_expr (TYPE_SIZE (type));
        !          9348:        opcode = storeBLK;
        !          9349:       }
        !          9350:     else
        !          9351:       opcode = mode_to_store_map [(int) TYPE_MODE (type)];
        !          9352: 
        !          9353:   if (opcode == neverneverland)
        !          9354:     abort ();
        !          9355: 
        !          9356:   bc_emit_bytecode (opcode);
        !          9357:   
        !          9358: #ifdef DEBUG_PRINT_CODE
        !          9359:   fputc ('\n', stderr);
        !          9360: #endif
        !          9361: }
        !          9362: 
        !          9363: 
        !          9364: /* Allocate local stack space sufficient to hold a value of the given
        !          9365:    SIZE at alignment boundary ALIGNMENT bits.  ALIGNMENT must be an
        !          9366:    integral power of 2.  A special case is locals of type VOID, which
        !          9367:    have size 0 and alignment 1 - any "voidish" SIZE or ALIGNMENT is
        !          9368:    remapped into the corresponding attribute of SI.  */
        !          9369: 
        !          9370: rtx
        !          9371: bc_allocate_local (size, alignment)
        !          9372:      int size, alignment;
        !          9373: {
        !          9374:   rtx retval;
        !          9375:   int byte_alignment;
        !          9376: 
        !          9377:   if (size < 0)
        !          9378:     abort ();
        !          9379: 
        !          9380:   /* Normalize size and alignment  */
        !          9381:   if (!size)
        !          9382:     size = UNITS_PER_WORD;
        !          9383: 
        !          9384:   if (alignment < BITS_PER_UNIT)
        !          9385:     byte_alignment = 1 << (INT_ALIGN - 1);
        !          9386:   else
        !          9387:     /* Align */
        !          9388:     byte_alignment = alignment / BITS_PER_UNIT;
        !          9389: 
        !          9390:   if (local_vars_size & (byte_alignment - 1))
        !          9391:     local_vars_size += byte_alignment - (local_vars_size & (byte_alignment - 1));
        !          9392: 
        !          9393:   retval = bc_gen_rtx ((char *) 0, local_vars_size, (struct bc_label *) 0);
        !          9394:   local_vars_size += size;
        !          9395: 
        !          9396:   return retval;
        !          9397: }
        !          9398: 
        !          9399: 
        !          9400: /* Allocate variable-sized local array. Variable-sized arrays are
        !          9401:    actually pointers to the address in memory where they are stored. */
        !          9402: 
        !          9403: rtx
        !          9404: bc_allocate_variable_array (size)
        !          9405:      tree size;
        !          9406: {
        !          9407:   rtx retval;
        !          9408:   const int ptralign = (1 << (PTR_ALIGN - 1));
        !          9409: 
        !          9410:   /* Align pointer */
        !          9411:   if (local_vars_size & ptralign)
        !          9412:     local_vars_size +=  ptralign - (local_vars_size & ptralign);
        !          9413: 
        !          9414:   /* Note down local space needed: pointer to block; also return
        !          9415:      dummy rtx */
        !          9416: 
        !          9417:   retval = bc_gen_rtx ((char *) 0, local_vars_size, (struct bc_label *) 0);
        !          9418:   local_vars_size += POINTER_SIZE / BITS_PER_UNIT;
        !          9419:   return retval;
        !          9420: }
        !          9421: 
        !          9422: 
        !          9423: /* Push the machine address for the given external variable offset.  */
        !          9424: void
        !          9425: bc_load_externaddr (externaddr)
        !          9426:      rtx externaddr;
        !          9427: {
        !          9428:   bc_emit_bytecode (constP);
        !          9429:   bc_emit_code_labelref (BYTECODE_LABEL (externaddr),
        !          9430:                         BYTECODE_BC_LABEL (externaddr)->offset);
        !          9431: 
        !          9432: #ifdef DEBUG_PRINT_CODE
        !          9433:   fputc ('\n', stderr);
        !          9434: #endif
        !          9435: }
        !          9436: 
        !          9437: 
        !          9438: static char *
        !          9439: bc_strdup (s)
        !          9440:     char *s;
        !          9441: {
        !          9442:   char *new = (char *) xmalloc ((strlen (s) + 1) * sizeof *s);
        !          9443:   strcpy (new, s);
        !          9444:   return new;
        !          9445: }
        !          9446: 
        !          9447: 
        !          9448: /* Like above, but expects an IDENTIFIER.  */
        !          9449: void
        !          9450: bc_load_externaddr_id (id, offset)
        !          9451:      tree id;
        !          9452:      int offset;
        !          9453: {
        !          9454:   if (!IDENTIFIER_POINTER (id))
        !          9455:     abort ();
        !          9456: 
        !          9457:   bc_emit_bytecode (constP);
        !          9458:   bc_emit_code_labelref (bc_xstrdup (IDENTIFIER_POINTER (id)), offset);
        !          9459: 
        !          9460: #ifdef DEBUG_PRINT_CODE
        !          9461:   fputc ('\n', stderr);
        !          9462: #endif
        !          9463: }
        !          9464: 
        !          9465: 
        !          9466: /* Push the machine address for the given local variable offset.  */
        !          9467: void
        !          9468: bc_load_localaddr (localaddr)
        !          9469:      rtx localaddr;
        !          9470: {
        !          9471:   bc_emit_instruction (localP, (HOST_WIDE_INT) BYTECODE_BC_LABEL (localaddr)->offset);
        !          9472: }
        !          9473: 
        !          9474: 
        !          9475: /* Push the machine address for the given parameter offset.
        !          9476:    NOTE: offset is in bits. */
        !          9477: void
        !          9478: bc_load_parmaddr (parmaddr)
        !          9479:      rtx parmaddr;
        !          9480: {
        !          9481:   bc_emit_instruction (argP, ((HOST_WIDE_INT) BYTECODE_BC_LABEL (parmaddr)->offset
        !          9482:                              / BITS_PER_UNIT));
        !          9483: }
        !          9484: 
        !          9485: 
        !          9486: /* Convert a[i] into *(a + i).  */
        !          9487: tree
        !          9488: bc_canonicalize_array_ref (exp)
        !          9489:      tree exp;
        !          9490: {
        !          9491:   tree type = TREE_TYPE (exp);
        !          9492:   tree array_adr = build1 (ADDR_EXPR, TYPE_POINTER_TO (type),
        !          9493:                           TREE_OPERAND (exp, 0));
        !          9494:   tree index = TREE_OPERAND (exp, 1);
        !          9495: 
        !          9496: 
        !          9497:   /* Convert the integer argument to a type the same size as a pointer
        !          9498:      so the multiply won't overflow spuriously.  */
        !          9499: 
        !          9500:   if (TYPE_PRECISION (TREE_TYPE (index)) != POINTER_SIZE)
        !          9501:     index = convert (type_for_size (POINTER_SIZE, 0), index);
        !          9502: 
        !          9503:   /* The array address isn't volatile even if the array is.
        !          9504:      (Of course this isn't terribly relevant since the bytecode
        !          9505:      translator treats nearly everything as volatile anyway.)  */
        !          9506:   TREE_THIS_VOLATILE (array_adr) = 0;
        !          9507: 
        !          9508:   return build1 (INDIRECT_REF, type,
        !          9509:                 fold (build (PLUS_EXPR,
        !          9510:                              TYPE_POINTER_TO (type),
        !          9511:                              array_adr,
        !          9512:                              fold (build (MULT_EXPR,
        !          9513:                                           TYPE_POINTER_TO (type),
        !          9514:                                           index,
        !          9515:                                           size_in_bytes (type))))));
        !          9516: }
        !          9517: 
        !          9518: 
        !          9519: /* Load the address of the component referenced by the given
        !          9520:    COMPONENT_REF expression.
        !          9521: 
        !          9522:    Returns innermost lvalue. */
        !          9523: 
        !          9524: tree
        !          9525: bc_expand_component_address (exp)
        !          9526:      tree exp;
        !          9527: {
        !          9528:   tree tem, chain;
        !          9529:   enum machine_mode mode;
        !          9530:   int bitpos = 0;
        !          9531:   HOST_WIDE_INT SIval;
        !          9532: 
        !          9533: 
        !          9534:   tem = TREE_OPERAND (exp, 1);
        !          9535:   mode = DECL_MODE (tem);
        !          9536: 
        !          9537: 
        !          9538:   /* Compute cumulative bit offset for nested component refs
        !          9539:      and array refs, and find the ultimate containing object.  */
        !          9540: 
        !          9541:   for (tem = exp;; tem = TREE_OPERAND (tem, 0))
        !          9542:     {
        !          9543:       if (TREE_CODE (tem) == COMPONENT_REF)
        !          9544:        bitpos += TREE_INT_CST_LOW (DECL_FIELD_BITPOS (TREE_OPERAND (tem, 1)));
        !          9545:       else
        !          9546:        if (TREE_CODE (tem) == ARRAY_REF
        !          9547:            && TREE_CODE (TREE_OPERAND (tem, 1)) == INTEGER_CST
        !          9548:            && TREE_CODE (TYPE_SIZE (TREE_TYPE (tem))) == INTEGER_CST)
        !          9549: 
        !          9550:          bitpos += (TREE_INT_CST_LOW (TREE_OPERAND (tem, 1))
        !          9551:                     * TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (tem)))
        !          9552:                     /* * TYPE_SIZE_UNIT (TREE_TYPE (tem)) */);
        !          9553:        else
        !          9554:          break;
        !          9555:     }
        !          9556: 
        !          9557:   bc_expand_expr (tem);
        !          9558: 
        !          9559: 
        !          9560:   /* For bitfields also push their offset and size */
        !          9561:   if (DECL_BIT_FIELD (TREE_OPERAND (exp, 1)))
        !          9562:     bc_push_offset_and_size (bitpos, /* DECL_SIZE_UNIT */ (TREE_OPERAND (exp, 1)));
        !          9563:   else
        !          9564:     if (SIval = bitpos / BITS_PER_UNIT)
        !          9565:       bc_emit_instruction (addconstPSI, SIval);
        !          9566: 
        !          9567:   return (TREE_OPERAND (exp, 1));
        !          9568: }
        !          9569: 
        !          9570: 
        !          9571: /* Emit code to push two SI constants */
        !          9572: void
        !          9573: bc_push_offset_and_size (offset, size)
        !          9574:      HOST_WIDE_INT offset, size;
        !          9575: {
        !          9576:   bc_emit_instruction (constSI, offset);
        !          9577:   bc_emit_instruction (constSI, size);
        !          9578: }
        !          9579: 
        !          9580: 
        !          9581: /* Emit byte code to push the address of the given lvalue expression to
        !          9582:    the stack.  If it's a bit field, we also push offset and size info.
        !          9583: 
        !          9584:    Returns innermost component, which allows us to determine not only
        !          9585:    its type, but also whether it's a bitfield. */
        !          9586: 
        !          9587: tree
        !          9588: bc_expand_address (exp)
        !          9589:      tree exp;
        !          9590: {
        !          9591:   /* Safeguard */
        !          9592:   if (!exp || TREE_CODE (exp) == ERROR_MARK)
        !          9593:     return (exp);
        !          9594: 
        !          9595: 
        !          9596:   switch (TREE_CODE (exp))
        !          9597:     {
        !          9598:     case ARRAY_REF:
        !          9599: 
        !          9600:       return (bc_expand_address (bc_canonicalize_array_ref (exp)));
        !          9601: 
        !          9602:     case COMPONENT_REF:
        !          9603: 
        !          9604:       return (bc_expand_component_address (exp));
        !          9605: 
        !          9606:     case INDIRECT_REF:
        !          9607: 
        !          9608:       bc_expand_expr (TREE_OPERAND (exp, 0));
        !          9609: 
        !          9610:       /* For variable-sized types: retrieve pointer.  Sometimes the
        !          9611:         TYPE_SIZE tree is NULL.  Is this a bug or a feature?  Let's
        !          9612:         also make sure we have an operand, just in case... */
        !          9613: 
        !          9614:       if (TREE_OPERAND (exp, 0)
        !          9615:          && TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)))
        !          9616:          && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)))) != INTEGER_CST)
        !          9617:        bc_emit_instruction (loadP);
        !          9618: 
        !          9619:       /* If packed, also return offset and size */
        !          9620:       if (DECL_BIT_FIELD (TREE_OPERAND (exp, 0)))
        !          9621:        
        !          9622:        bc_push_offset_and_size (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (TREE_OPERAND (exp, 0))),
        !          9623:                                 TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (exp, 0))));
        !          9624: 
        !          9625:       return (TREE_OPERAND (exp, 0));
        !          9626: 
        !          9627:     case FUNCTION_DECL:
        !          9628: 
        !          9629:       bc_load_externaddr_id (DECL_ASSEMBLER_NAME (exp),
        !          9630:                             BYTECODE_BC_LABEL (DECL_RTL (exp))->offset);
        !          9631:       break;
        !          9632: 
        !          9633:     case PARM_DECL:
        !          9634: 
        !          9635:       bc_load_parmaddr (DECL_RTL (exp));
        !          9636: 
        !          9637:       /* For variable-sized types: retrieve pointer */
        !          9638:       if (TYPE_SIZE (TREE_TYPE (exp))
        !          9639:          && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST)
        !          9640:        bc_emit_instruction (loadP);
        !          9641: 
        !          9642:       /* If packed, also return offset and size */
        !          9643:       if (DECL_BIT_FIELD (exp))
        !          9644:        bc_push_offset_and_size (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (exp)),
        !          9645:                                 TREE_INT_CST_LOW (DECL_SIZE (exp)));
        !          9646: 
        !          9647:       break;
        !          9648: 
        !          9649:     case RESULT_DECL:
        !          9650: 
        !          9651:       bc_emit_instruction (returnP);
        !          9652:       break;
        !          9653: 
        !          9654:     case VAR_DECL:
        !          9655: 
        !          9656: #if 0
        !          9657:       if (BYTECODE_LABEL (DECL_RTL (exp)))
        !          9658:        bc_load_externaddr (DECL_RTL (exp));
        !          9659: #endif
        !          9660: 
        !          9661:       if (DECL_EXTERNAL (exp))
        !          9662:        bc_load_externaddr_id (DECL_ASSEMBLER_NAME (exp),
        !          9663:                               (BYTECODE_BC_LABEL (DECL_RTL (exp)))->offset);
        !          9664:       else
        !          9665:        bc_load_localaddr (DECL_RTL (exp));
        !          9666: 
        !          9667:       /* For variable-sized types: retrieve pointer */
        !          9668:       if (TYPE_SIZE (TREE_TYPE (exp))
        !          9669:          && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST)
        !          9670:        bc_emit_instruction (loadP);
        !          9671: 
        !          9672:       /* If packed, also return offset and size */
        !          9673:       if (DECL_BIT_FIELD (exp))
        !          9674:        bc_push_offset_and_size (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (exp)),
        !          9675:                                 TREE_INT_CST_LOW (DECL_SIZE (exp)));
        !          9676:       
        !          9677:       break;
        !          9678: 
        !          9679:     case STRING_CST:
        !          9680:       {
        !          9681:        rtx r;
        !          9682:        
        !          9683:        bc_emit_bytecode (constP);
        !          9684:        r = output_constant_def (exp);
        !          9685:        bc_emit_code_labelref (BYTECODE_LABEL (r), BYTECODE_BC_LABEL (r)->offset);
        !          9686: 
        !          9687: #ifdef DEBUG_PRINT_CODE
        !          9688:        fputc ('\n', stderr);
        !          9689: #endif
        !          9690:       }
        !          9691:       break;
        !          9692: 
        !          9693:     default:
        !          9694: 
        !          9695:       abort();
        !          9696:       break;
        !          9697:     }
        !          9698: 
        !          9699:   /* Most lvalues don't have components. */
        !          9700:   return (exp);
        !          9701: }
        !          9702: 
        !          9703: 
        !          9704: /* Emit a type code to be used by the runtime support in handling
        !          9705:    parameter passing.   The type code consists of the machine mode
        !          9706:    plus the minimal alignment shifted left 8 bits.  */
        !          9707: 
        !          9708: tree
        !          9709: bc_runtime_type_code (type)
        !          9710:      tree type;
        !          9711: {
        !          9712:   int val;
        !          9713: 
        !          9714:   switch (TREE_CODE (type))
        !          9715:     {
        !          9716:     case VOID_TYPE:
        !          9717:     case INTEGER_TYPE:
        !          9718:     case REAL_TYPE:
        !          9719:     case COMPLEX_TYPE:
        !          9720:     case ENUMERAL_TYPE:
        !          9721:     case POINTER_TYPE:
        !          9722:     case RECORD_TYPE:
        !          9723: 
        !          9724:       val = (int) TYPE_MODE (type) | TYPE_ALIGN (type) << 8;
        !          9725:       break;
        !          9726: 
        !          9727:     case ERROR_MARK:
        !          9728: 
        !          9729:       val = 0;
        !          9730:       break;
        !          9731: 
        !          9732:     default:
        !          9733: 
        !          9734:       abort ();
        !          9735:     }
        !          9736:   return build_int_2 (val, 0);
        !          9737: }
        !          9738: 
        !          9739: 
        !          9740: /* Generate constructor label */
        !          9741: char *
        !          9742: bc_gen_constr_label ()
        !          9743: {
        !          9744:   static int label_counter;
        !          9745:   static char label[20];
        !          9746: 
        !          9747:   sprintf (label, "*LR%d", label_counter++);
        !          9748: 
        !          9749:   return (obstack_copy0 (&permanent_obstack, label, strlen (label)));
        !          9750: }
        !          9751: 
        !          9752: 
        !          9753: /* Evaluate constructor CONSTR and return pointer to it on level one.  We
        !          9754:    expand the constructor data as static data, and push a pointer to it.
        !          9755:    The pointer is put in the pointer table and is retrieved by a constP
        !          9756:    bytecode instruction.  We then loop and store each constructor member in
        !          9757:    the corresponding component.  Finally, we return the original pointer on
        !          9758:    the stack. */
        !          9759: 
        !          9760: void
        !          9761: bc_expand_constructor (constr)
        !          9762:      tree constr;
        !          9763: {
        !          9764:   char *l;
        !          9765:   HOST_WIDE_INT ptroffs;
        !          9766:   rtx constr_rtx;
        !          9767: 
        !          9768:   
        !          9769:   /* Literal constructors are handled as constants, whereas
        !          9770:      non-literals are evaluated and stored element by element
        !          9771:      into the data segment. */
        !          9772:   
        !          9773:   /* Allocate space in proper segment and push pointer to space on stack.
        !          9774:    */
        !          9775: 
        !          9776:   l = bc_gen_constr_label ();
        !          9777: 
        !          9778:   if (TREE_CONSTANT (constr))
        !          9779:     {
        !          9780:       text_section ();
        !          9781: 
        !          9782:       bc_emit_const_labeldef (l);
        !          9783:       bc_output_constructor (constr, int_size_in_bytes (TREE_TYPE (constr)));
        !          9784:     }
        !          9785:   else
        !          9786:     {
        !          9787:       data_section ();
        !          9788: 
        !          9789:       bc_emit_data_labeldef (l);
        !          9790:       bc_output_data_constructor (constr);
        !          9791:     }
        !          9792: 
        !          9793:   
        !          9794:   /* Add reference to pointer table and recall pointer to stack;
        !          9795:      this code is common for both types of constructors: literals
        !          9796:      and non-literals. */
        !          9797: 
        !          9798:   ptroffs = bc_define_pointer (l);
        !          9799:   bc_emit_instruction (constP, ptroffs);
        !          9800: 
        !          9801:   /* This is all that has to be done if it's a literal. */
        !          9802:   if (TREE_CONSTANT (constr))
        !          9803:     return;
        !          9804: 
        !          9805: 
        !          9806:   /* At this point, we have the pointer to the structure on top of the stack.
        !          9807:      Generate sequences of store_memory calls for the constructor. */
        !          9808:   
        !          9809:   /* constructor type is structure */
        !          9810:   if (TREE_CODE (TREE_TYPE (constr)) == RECORD_TYPE)
        !          9811:     {
        !          9812:       register tree elt;
        !          9813:       
        !          9814:       /* If the constructor has fewer fields than the structure,
        !          9815:         clear the whole structure first.  */
        !          9816:       
        !          9817:       if (list_length (CONSTRUCTOR_ELTS (constr))
        !          9818:          != list_length (TYPE_FIELDS (TREE_TYPE (constr))))
        !          9819:        {
        !          9820:          bc_emit_instruction (duplicate);
        !          9821:          bc_emit_instruction (constSI, (HOST_WIDE_INT) int_size_in_bytes (TREE_TYPE (constr)));
        !          9822:          bc_emit_instruction (clearBLK);
        !          9823:        }
        !          9824:       
        !          9825:       /* Store each element of the constructor into the corresponding
        !          9826:         field of TARGET.  */
        !          9827:       
        !          9828:       for (elt = CONSTRUCTOR_ELTS (constr); elt; elt = TREE_CHAIN (elt))
        !          9829:        {
        !          9830:          register tree field = TREE_PURPOSE (elt);
        !          9831:          register enum machine_mode mode;
        !          9832:          int bitsize;
        !          9833:          int bitpos;
        !          9834:          int unsignedp;
        !          9835:          
        !          9836:          bitsize = TREE_INT_CST_LOW (DECL_SIZE (field)) /* * DECL_SIZE_UNIT (field) */;
        !          9837:          mode = DECL_MODE (field);
        !          9838:          unsignedp = TREE_UNSIGNED (field);
        !          9839: 
        !          9840:          bitpos = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field));
        !          9841:          
        !          9842:          bc_store_field (elt, bitsize, bitpos, mode, TREE_VALUE (elt), TREE_TYPE (TREE_VALUE (elt)),
        !          9843:                          /* The alignment of TARGET is
        !          9844:                             at least what its type requires.  */
        !          9845:                          VOIDmode, 0,
        !          9846:                          TYPE_ALIGN (TREE_TYPE (constr)) / BITS_PER_UNIT,
        !          9847:                          int_size_in_bytes (TREE_TYPE (constr)));
        !          9848:        }
        !          9849:     }
        !          9850:   else
        !          9851:     
        !          9852:     /* Constructor type is array */
        !          9853:     if (TREE_CODE (TREE_TYPE (constr)) == ARRAY_TYPE)
        !          9854:       {
        !          9855:        register tree elt;
        !          9856:        register int i;
        !          9857:        tree domain = TYPE_DOMAIN (TREE_TYPE (constr));
        !          9858:        int minelt = TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain));
        !          9859:        int maxelt = TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain));
        !          9860:        tree elttype = TREE_TYPE (TREE_TYPE (constr));
        !          9861:        
        !          9862:        /* If the constructor has fewer fields than the structure,
        !          9863:           clear the whole structure first.  */
        !          9864:        
        !          9865:        if (list_length (CONSTRUCTOR_ELTS (constr)) < maxelt - minelt + 1)
        !          9866:          {
        !          9867:            bc_emit_instruction (duplicate);
        !          9868:            bc_emit_instruction (constSI, (HOST_WIDE_INT) int_size_in_bytes (TREE_TYPE (constr)));
        !          9869:            bc_emit_instruction (clearBLK);
        !          9870:          }
        !          9871:        
        !          9872:        
        !          9873:        /* Store each element of the constructor into the corresponding
        !          9874:           element of TARGET, determined by counting the elements. */
        !          9875:        
        !          9876:        for (elt = CONSTRUCTOR_ELTS (constr), i = 0;
        !          9877:             elt;
        !          9878:             elt = TREE_CHAIN (elt), i++)
        !          9879:          {
        !          9880:            register enum machine_mode mode;
        !          9881:            int bitsize;
        !          9882:            int bitpos;
        !          9883:            int unsignedp;
        !          9884:            
        !          9885:            mode = TYPE_MODE (elttype);
        !          9886:            bitsize = GET_MODE_BITSIZE (mode);
        !          9887:            unsignedp = TREE_UNSIGNED (elttype);
        !          9888:            
        !          9889:            bitpos = (i * TREE_INT_CST_LOW (TYPE_SIZE (elttype))
        !          9890:                      /* * TYPE_SIZE_UNIT (elttype) */ );
        !          9891:            
        !          9892:            bc_store_field (elt, bitsize, bitpos, mode,
        !          9893:                            TREE_VALUE (elt), TREE_TYPE (TREE_VALUE (elt)),
        !          9894:                            /* The alignment of TARGET is
        !          9895:                               at least what its type requires.  */
        !          9896:                            VOIDmode, 0,
        !          9897:                            TYPE_ALIGN (TREE_TYPE (constr)) / BITS_PER_UNIT,
        !          9898:                            int_size_in_bytes (TREE_TYPE (constr)));
        !          9899:          }
        !          9900:   
        !          9901:       }
        !          9902: }
        !          9903: 
        !          9904: 
        !          9905: /* Store the value of EXP (an expression tree) into member FIELD of
        !          9906:    structure at address on stack, which has type TYPE, mode MODE and
        !          9907:    occupies BITSIZE bits, starting BITPOS bits from the beginning of the
        !          9908:    structure.
        !          9909: 
        !          9910:    ALIGN is the alignment that TARGET is known to have, measured in bytes.
        !          9911:    TOTAL_SIZE is its size in bytes, or -1 if variable.  */
        !          9912: 
        !          9913: void
        !          9914: bc_store_field (field, bitsize, bitpos, mode, exp, type,
        !          9915:                value_mode, unsignedp, align, total_size)
        !          9916:      int bitsize, bitpos;
        !          9917:      enum machine_mode mode;
        !          9918:      tree field, exp, type;
        !          9919:      enum machine_mode value_mode;
        !          9920:      int unsignedp;
        !          9921:      int align;
        !          9922:      int total_size;
        !          9923: {
        !          9924: 
        !          9925:   /* Expand expression and copy pointer */
        !          9926:   bc_expand_expr (exp);
        !          9927:   bc_emit_instruction (over);
        !          9928: 
        !          9929: 
        !          9930:   /* If the component is a bit field, we cannot use addressing to access
        !          9931:      it.  Use bit-field techniques to store in it.  */
        !          9932: 
        !          9933:   if (DECL_BIT_FIELD (field))
        !          9934:     {
        !          9935:       bc_store_bit_field (bitpos, bitsize, unsignedp);
        !          9936:       return;
        !          9937:     }
        !          9938:   else
        !          9939:     /* Not bit field */
        !          9940:     {
        !          9941:       HOST_WIDE_INT offset = bitpos / BITS_PER_UNIT;
        !          9942: 
        !          9943:       /* Advance pointer to the desired member */
        !          9944:       if (offset)
        !          9945:        bc_emit_instruction (addconstPSI, offset);
        !          9946: 
        !          9947:       /* Store */
        !          9948:       bc_store_memory (type, field);
        !          9949:     }
        !          9950: }
        !          9951: 
        !          9952: 
        !          9953: /* Store SI/SU in bitfield */
        !          9954: void
        !          9955: bc_store_bit_field (offset, size, unsignedp)
        !          9956:      int offset, size, unsignedp;
        !          9957: {
        !          9958:   /* Push bitfield offset and size */
        !          9959:   bc_push_offset_and_size (offset, size);
        !          9960: 
        !          9961:   /* Store */
        !          9962:   bc_emit_instruction (sstoreBI);
        !          9963: }
        !          9964: 
        !          9965: 
        !          9966: /* Load SI/SU from bitfield */
        !          9967: void
        !          9968: bc_load_bit_field (offset, size, unsignedp)
        !          9969:      int offset, size, unsignedp;
        !          9970: {
        !          9971:   /* Push bitfield offset and size */
        !          9972:   bc_push_offset_and_size (offset, size);
        !          9973: 
        !          9974:   /* Load: sign-extend if signed, else zero-extend */
        !          9975:   bc_emit_instruction (unsignedp ? zxloadBI : sxloadBI);
        !          9976: }  
        !          9977: 
        !          9978: 
        !          9979: /* Adjust interpreter stack by NLEVELS.  Positive means drop NLEVELS
        !          9980:    (adjust stack pointer upwards), negative means add that number of
        !          9981:    levels (adjust the stack pointer downwards).  Only positive values
        !          9982:    normally make sense. */
        !          9983: 
        !          9984: void
        !          9985: bc_adjust_stack (nlevels)
        !          9986:      int nlevels;
        !          9987: {
        !          9988:   switch (nlevels)
        !          9989:     {
        !          9990:     case 0:
        !          9991:       break;
        !          9992:       
        !          9993:     case 2:
        !          9994:       bc_emit_instruction (drop);
        !          9995:       
        !          9996:     case 1:
        !          9997:       bc_emit_instruction (drop);
        !          9998:       break;
        !          9999:       
        !          10000:     default:
        !          10001:       
        !          10002:       bc_emit_instruction (adjstackSI, (HOST_WIDE_INT) nlevels);
        !          10003:       stack_depth -= nlevels;
        !          10004:     }
        !          10005: 
        !          10006: #if defined (VALIDATE_STACK_FOR_BC)
        !          10007:   VALIDATE_STACK_FOR_BC ();
        !          10008: #endif
        !          10009: }