1 /* Expands front end tree to back end RTL for GCC
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* This file handles the generation of rtl code from tree structure
23 above the level of expressions, using subroutines in exp*.c and emit-rtl.c.
24 The functions whose names start with `expand_' are called by the
25 expander to generate RTL instructions for various kinds of constructs. */
29 #include "coretypes.h"
33 #include "hard-reg-set.h"
39 #include "insn-config.h"
47 #include "langhooks.h"
52 #include "alloc-pool.h"
54 /* Functions and data structures for expanding case statements. */
56 /* Case label structure, used to hold info on labels within case
57 statements. We handle "range" labels; for a single-value label
58 as in C, the high and low limits are the same.
60 We start with a vector of case nodes sorted in ascending order, and
61 the default label as the last element in the vector. Before expanding
62 to RTL, we transform this vector into a list linked via the RIGHT
63 fields in the case_node struct. Nodes with higher case values are
66 Switch statements can be output in three forms. A branch table is
67 used if there are more than a few labels and the labels are dense
68 within the range between the smallest and largest case value. If a
69 branch table is used, no further manipulations are done with the case
72 The alternative to the use of a branch table is to generate a series
73 of compare and jump insns. When that is done, we use the LEFT, RIGHT,
74 and PARENT fields to hold a binary tree. Initially the tree is
75 totally unbalanced, with everything on the right. We balance the tree
76 with nodes on the left having lower case values than the parent
77 and nodes on the right having higher values. We then output the tree
80 For very small, suitable switch statements, we can generate a series
81 of simple bit test and branches instead. */
85 struct case_node
*left
; /* Left son in binary tree */
86 struct case_node
*right
; /* Right son in binary tree; also node chain */
87 struct case_node
*parent
; /* Parent of node in binary tree */
88 tree low
; /* Lowest index value for this label */
89 tree high
; /* Highest index value for this label */
90 tree code_label
; /* Label to jump to when node matches */
93 typedef struct case_node case_node
;
94 typedef struct case_node
*case_node_ptr
;
96 /* These are used by estimate_case_costs and balance_case_nodes. */
98 /* This must be a signed type, and non-ANSI compilers lack signed char. */
99 static short cost_table_
[129];
100 static int use_cost_table
;
101 static int cost_table_initialized
;
103 /* Special care is needed because we allow -1, but TREE_INT_CST_LOW
105 #define COST_TABLE(I) cost_table_[(unsigned HOST_WIDE_INT) ((I) + 1)]
107 static int n_occurrences (int, const char *);
108 static bool tree_conflicts_with_clobbers_p (tree
, HARD_REG_SET
*);
109 static void expand_nl_goto_receiver (void);
110 static bool check_operand_nalternatives (tree
, tree
);
111 static bool check_unique_operand_names (tree
, tree
);
112 static char *resolve_operand_name_1 (char *, tree
, tree
);
113 static void expand_null_return_1 (void);
114 static void expand_value_return (rtx
);
115 static int estimate_case_costs (case_node_ptr
);
116 static bool lshift_cheap_p (void);
117 static int case_bit_test_cmp (const void *, const void *);
118 static void emit_case_bit_tests (tree
, tree
, tree
, tree
, case_node_ptr
, rtx
);
119 static void balance_case_nodes (case_node_ptr
*, case_node_ptr
);
120 static int node_has_low_bound (case_node_ptr
, tree
);
121 static int node_has_high_bound (case_node_ptr
, tree
);
122 static int node_is_bounded (case_node_ptr
, tree
);
123 static void emit_case_nodes (rtx
, case_node_ptr
, rtx
, tree
);
124 static struct case_node
*add_case_node (struct case_node
*, tree
,
125 tree
, tree
, tree
, alloc_pool
);
128 /* Return the rtx-label that corresponds to a LABEL_DECL,
129 creating it if necessary. */
132 label_rtx (tree label
)
134 gcc_assert (TREE_CODE (label
) == LABEL_DECL
);
136 if (!DECL_RTL_SET_P (label
))
138 rtx r
= gen_label_rtx ();
139 SET_DECL_RTL (label
, r
);
140 if (FORCED_LABEL (label
) || DECL_NONLOCAL (label
))
141 LABEL_PRESERVE_P (r
) = 1;
144 return DECL_RTL (label
);
147 /* As above, but also put it on the forced-reference list of the
148 function that contains it. */
150 force_label_rtx (tree label
)
152 rtx ref
= label_rtx (label
);
153 tree function
= decl_function_context (label
);
156 gcc_assert (function
);
158 if (function
!= current_function_decl
)
159 p
= find_function_data (function
);
163 forced_labels
= gen_rtx_EXPR_LIST (VOIDmode
, ref
, forced_labels
);
167 /* Add an unconditional jump to LABEL as the next sequential instruction. */
170 emit_jump (rtx label
)
172 do_pending_stack_adjust ();
173 emit_jump_insn (gen_jump (label
));
177 /* Emit code to jump to the address
178 specified by the pointer expression EXP. */
181 expand_computed_goto (tree exp
)
183 rtx x
= expand_normal (exp
);
185 x
= convert_memory_address (Pmode
, x
);
187 do_pending_stack_adjust ();
188 emit_indirect_jump (x
);
191 /* Handle goto statements and the labels that they can go to. */
193 /* Specify the location in the RTL code of a label LABEL,
194 which is a LABEL_DECL tree node.
196 This is used for the kind of label that the user can jump to with a
197 goto statement, and for alternatives of a switch or case statement.
198 RTL labels generated for loops and conditionals don't go through here;
199 they are generated directly at the RTL level, by other functions below.
201 Note that this has nothing to do with defining label *names*.
202 Languages vary in how they do that and what that even means. */
205 expand_label (tree label
)
207 rtx label_r
= label_rtx (label
);
209 do_pending_stack_adjust ();
210 emit_label (label_r
);
211 if (DECL_NAME (label
))
212 LABEL_NAME (DECL_RTL (label
)) = IDENTIFIER_POINTER (DECL_NAME (label
));
214 if (DECL_NONLOCAL (label
))
216 expand_nl_goto_receiver ();
217 nonlocal_goto_handler_labels
218 = gen_rtx_EXPR_LIST (VOIDmode
, label_r
,
219 nonlocal_goto_handler_labels
);
222 if (FORCED_LABEL (label
))
223 forced_labels
= gen_rtx_EXPR_LIST (VOIDmode
, label_r
, forced_labels
);
225 if (DECL_NONLOCAL (label
) || FORCED_LABEL (label
))
226 maybe_set_first_label_num (label_r
);
229 /* Generate RTL code for a `goto' statement with target label LABEL.
230 LABEL should be a LABEL_DECL tree node that was or will later be
231 defined with `expand_label'. */
234 expand_goto (tree label
)
236 #ifdef ENABLE_CHECKING
237 /* Check for a nonlocal goto to a containing function. Should have
238 gotten translated to __builtin_nonlocal_goto. */
239 tree context
= decl_function_context (label
);
240 gcc_assert (!context
|| context
== current_function_decl
);
243 emit_jump (label_rtx (label
));
246 /* Return the number of times character C occurs in string S. */
248 n_occurrences (int c
, const char *s
)
256 /* Generate RTL for an asm statement (explicit assembler code).
257 STRING is a STRING_CST node containing the assembler code text,
258 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
259 insn is volatile; don't optimize it. */
262 expand_asm_loc (tree string
, int vol
, location_t locus
)
266 if (TREE_CODE (string
) == ADDR_EXPR
)
267 string
= TREE_OPERAND (string
, 0);
269 body
= gen_rtx_ASM_INPUT_loc (VOIDmode
,
270 ggc_strdup (TREE_STRING_POINTER (string
)),
273 MEM_VOLATILE_P (body
) = vol
;
278 /* Parse the output constraint pointed to by *CONSTRAINT_P. It is the
279 OPERAND_NUMth output operand, indexed from zero. There are NINPUTS
280 inputs and NOUTPUTS outputs to this extended-asm. Upon return,
281 *ALLOWS_MEM will be TRUE iff the constraint allows the use of a
282 memory operand. Similarly, *ALLOWS_REG will be TRUE iff the
283 constraint allows the use of a register operand. And, *IS_INOUT
284 will be true if the operand is read-write, i.e., if it is used as
285 an input as well as an output. If *CONSTRAINT_P is not in
286 canonical form, it will be made canonical. (Note that `+' will be
287 replaced with `=' as part of this process.)
289 Returns TRUE if all went well; FALSE if an error occurred. */
292 parse_output_constraint (const char **constraint_p
, int operand_num
,
293 int ninputs
, int noutputs
, bool *allows_mem
,
294 bool *allows_reg
, bool *is_inout
)
296 const char *constraint
= *constraint_p
;
299 /* Assume the constraint doesn't allow the use of either a register
304 /* Allow the `=' or `+' to not be at the beginning of the string,
305 since it wasn't explicitly documented that way, and there is a
306 large body of code that puts it last. Swap the character to
307 the front, so as not to uglify any place else. */
308 p
= strchr (constraint
, '=');
310 p
= strchr (constraint
, '+');
312 /* If the string doesn't contain an `=', issue an error
316 error ("output operand constraint lacks %<=%>");
320 /* If the constraint begins with `+', then the operand is both read
321 from and written to. */
322 *is_inout
= (*p
== '+');
324 /* Canonicalize the output constraint so that it begins with `='. */
325 if (p
!= constraint
|| *is_inout
)
328 size_t c_len
= strlen (constraint
);
331 warning (0, "output constraint %qc for operand %d "
332 "is not at the beginning",
335 /* Make a copy of the constraint. */
336 buf
= XALLOCAVEC (char, c_len
+ 1);
337 strcpy (buf
, constraint
);
338 /* Swap the first character and the `=' or `+'. */
339 buf
[p
- constraint
] = buf
[0];
340 /* Make sure the first character is an `='. (Until we do this,
341 it might be a `+'.) */
343 /* Replace the constraint with the canonicalized string. */
344 *constraint_p
= ggc_alloc_string (buf
, c_len
);
345 constraint
= *constraint_p
;
348 /* Loop through the constraint string. */
349 for (p
= constraint
+ 1; *p
; p
+= CONSTRAINT_LEN (*p
, p
))
354 error ("operand constraint contains incorrectly positioned "
359 if (operand_num
+ 1 == ninputs
+ noutputs
)
361 error ("%<%%%> constraint used with last operand");
366 case 'V': case TARGET_MEM_CONSTRAINT
: case 'o':
370 case '?': case '!': case '*': case '&': case '#':
371 case 'E': case 'F': case 'G': case 'H':
372 case 's': case 'i': case 'n':
373 case 'I': case 'J': case 'K': case 'L': case 'M':
374 case 'N': case 'O': case 'P': case ',':
377 case '0': case '1': case '2': case '3': case '4':
378 case '5': case '6': case '7': case '8': case '9':
380 error ("matching constraint not valid in output operand");
384 /* ??? Before flow, auto inc/dec insns are not supposed to exist,
385 excepting those that expand_call created. So match memory
402 if (REG_CLASS_FROM_CONSTRAINT (*p
, p
) != NO_REGS
)
404 #ifdef EXTRA_CONSTRAINT_STR
405 else if (EXTRA_ADDRESS_CONSTRAINT (*p
, p
))
407 else if (EXTRA_MEMORY_CONSTRAINT (*p
, p
))
411 /* Otherwise we can't assume anything about the nature of
412 the constraint except that it isn't purely registers.
413 Treat it like "g" and hope for the best. */
424 /* Similar, but for input constraints. */
427 parse_input_constraint (const char **constraint_p
, int input_num
,
428 int ninputs
, int noutputs
, int ninout
,
429 const char * const * constraints
,
430 bool *allows_mem
, bool *allows_reg
)
432 const char *constraint
= *constraint_p
;
433 const char *orig_constraint
= constraint
;
434 size_t c_len
= strlen (constraint
);
436 bool saw_match
= false;
438 /* Assume the constraint doesn't allow the use of either
439 a register or memory. */
443 /* Make sure constraint has neither `=', `+', nor '&'. */
445 for (j
= 0; j
< c_len
; j
+= CONSTRAINT_LEN (constraint
[j
], constraint
+j
))
446 switch (constraint
[j
])
448 case '+': case '=': case '&':
449 if (constraint
== orig_constraint
)
451 error ("input operand constraint contains %qc", constraint
[j
]);
457 if (constraint
== orig_constraint
458 && input_num
+ 1 == ninputs
- ninout
)
460 error ("%<%%%> constraint used with last operand");
465 case 'V': case TARGET_MEM_CONSTRAINT
: case 'o':
470 case '?': case '!': case '*': case '#':
471 case 'E': case 'F': case 'G': case 'H':
472 case 's': case 'i': case 'n':
473 case 'I': case 'J': case 'K': case 'L': case 'M':
474 case 'N': case 'O': case 'P': case ',':
477 /* Whether or not a numeric constraint allows a register is
478 decided by the matching constraint, and so there is no need
479 to do anything special with them. We must handle them in
480 the default case, so that we don't unnecessarily force
481 operands to memory. */
482 case '0': case '1': case '2': case '3': case '4':
483 case '5': case '6': case '7': case '8': case '9':
490 match
= strtoul (constraint
+ j
, &end
, 10);
491 if (match
>= (unsigned long) noutputs
)
493 error ("matching constraint references invalid operand number");
497 /* Try and find the real constraint for this dup. Only do this
498 if the matching constraint is the only alternative. */
500 && (j
== 0 || (j
== 1 && constraint
[0] == '%')))
502 constraint
= constraints
[match
];
503 *constraint_p
= constraint
;
504 c_len
= strlen (constraint
);
506 /* ??? At the end of the loop, we will skip the first part of
507 the matched constraint. This assumes not only that the
508 other constraint is an output constraint, but also that
509 the '=' or '+' come first. */
513 j
= end
- constraint
;
514 /* Anticipate increment at end of loop. */
529 if (! ISALPHA (constraint
[j
]))
531 error ("invalid punctuation %qc in constraint", constraint
[j
]);
534 if (REG_CLASS_FROM_CONSTRAINT (constraint
[j
], constraint
+ j
)
537 #ifdef EXTRA_CONSTRAINT_STR
538 else if (EXTRA_ADDRESS_CONSTRAINT (constraint
[j
], constraint
+ j
))
540 else if (EXTRA_MEMORY_CONSTRAINT (constraint
[j
], constraint
+ j
))
544 /* Otherwise we can't assume anything about the nature of
545 the constraint except that it isn't purely registers.
546 Treat it like "g" and hope for the best. */
554 if (saw_match
&& !*allows_reg
)
555 warning (0, "matching constraint does not allow a register");
560 /* Return DECL iff there's an overlap between *REGS and DECL, where DECL
561 can be an asm-declared register. Called via walk_tree. */
564 decl_overlaps_hard_reg_set_p (tree
*declp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
568 const HARD_REG_SET
*const regs
= (const HARD_REG_SET
*) data
;
570 if (TREE_CODE (decl
) == VAR_DECL
)
572 if (DECL_HARD_REGISTER (decl
)
573 && REG_P (DECL_RTL (decl
))
574 && REGNO (DECL_RTL (decl
)) < FIRST_PSEUDO_REGISTER
)
576 rtx reg
= DECL_RTL (decl
);
578 if (overlaps_hard_reg_set_p (*regs
, GET_MODE (reg
), REGNO (reg
)))
583 else if (TYPE_P (decl
) || TREE_CODE (decl
) == PARM_DECL
)
588 /* If there is an overlap between *REGS and DECL, return the first overlap
591 tree_overlaps_hard_reg_set (tree decl
, HARD_REG_SET
*regs
)
593 return walk_tree (&decl
, decl_overlaps_hard_reg_set_p
, regs
, NULL
);
596 /* Check for overlap between registers marked in CLOBBERED_REGS and
597 anything inappropriate in T. Emit error and return the register
598 variable definition for error, NULL_TREE for ok. */
601 tree_conflicts_with_clobbers_p (tree t
, HARD_REG_SET
*clobbered_regs
)
603 /* Conflicts between asm-declared register variables and the clobber
604 list are not allowed. */
605 tree overlap
= tree_overlaps_hard_reg_set (t
, clobbered_regs
);
609 error ("asm-specifier for variable %qs conflicts with asm clobber list",
610 IDENTIFIER_POINTER (DECL_NAME (overlap
)));
612 /* Reset registerness to stop multiple errors emitted for a single
614 DECL_REGISTER (overlap
) = 0;
621 /* Generate RTL for an asm statement with arguments.
622 STRING is the instruction template.
623 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
624 Each output or input has an expression in the TREE_VALUE and
625 a tree list in TREE_PURPOSE which in turn contains a constraint
626 name in TREE_VALUE (or NULL_TREE) and a constraint string
628 CLOBBERS is a list of STRING_CST nodes each naming a hard register
629 that is clobbered by this insn.
631 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
632 Some elements of OUTPUTS may be replaced with trees representing temporary
633 values. The caller should copy those temporary values to the originally
636 VOL nonzero means the insn is volatile; don't optimize it. */
639 expand_asm_operands (tree string
, tree outputs
, tree inputs
,
640 tree clobbers
, int vol
, location_t locus
)
642 rtvec argvec
, constraintvec
;
644 int ninputs
= list_length (inputs
);
645 int noutputs
= list_length (outputs
);
648 HARD_REG_SET clobbered_regs
;
649 int clobber_conflict_found
= 0;
653 /* Vector of RTX's of evaluated output operands. */
654 rtx
*output_rtx
= XALLOCAVEC (rtx
, noutputs
);
655 int *inout_opnum
= XALLOCAVEC (int, noutputs
);
656 rtx
*real_output_rtx
= XALLOCAVEC (rtx
, noutputs
);
657 enum machine_mode
*inout_mode
= XALLOCAVEC (enum machine_mode
, noutputs
);
658 const char **constraints
= XALLOCAVEC (const char *, noutputs
+ ninputs
);
659 int old_generating_concat_p
= generating_concat_p
;
661 /* An ASM with no outputs needs to be treated as volatile, for now. */
665 if (! check_operand_nalternatives (outputs
, inputs
))
668 string
= resolve_asm_operand_names (string
, outputs
, inputs
);
670 /* Collect constraints. */
672 for (t
= outputs
; t
; t
= TREE_CHAIN (t
), i
++)
673 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
674 for (t
= inputs
; t
; t
= TREE_CHAIN (t
), i
++)
675 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
677 /* Sometimes we wish to automatically clobber registers across an asm.
678 Case in point is when the i386 backend moved from cc0 to a hard reg --
679 maintaining source-level compatibility means automatically clobbering
680 the flags register. */
681 clobbers
= targetm
.md_asm_clobbers (outputs
, inputs
, clobbers
);
683 /* Count the number of meaningful clobbered registers, ignoring what
684 we would ignore later. */
686 CLEAR_HARD_REG_SET (clobbered_regs
);
687 for (tail
= clobbers
; tail
; tail
= TREE_CHAIN (tail
))
691 if (TREE_VALUE (tail
) == error_mark_node
)
693 regname
= TREE_STRING_POINTER (TREE_VALUE (tail
));
695 i
= decode_reg_name (regname
);
696 if (i
>= 0 || i
== -4)
699 error ("unknown register name %qs in %<asm%>", regname
);
701 /* Mark clobbered registers. */
704 /* Clobbering the PIC register is an error. */
705 if (i
== (int) PIC_OFFSET_TABLE_REGNUM
)
707 error ("PIC register %qs clobbered in %<asm%>", regname
);
711 SET_HARD_REG_BIT (clobbered_regs
, i
);
715 /* First pass over inputs and outputs checks validity and sets
716 mark_addressable if needed. */
719 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
721 tree val
= TREE_VALUE (tail
);
722 tree type
= TREE_TYPE (val
);
723 const char *constraint
;
728 /* If there's an erroneous arg, emit no insn. */
729 if (type
== error_mark_node
)
732 /* Try to parse the output constraint. If that fails, there's
733 no point in going further. */
734 constraint
= constraints
[i
];
735 if (!parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
736 &allows_mem
, &allows_reg
, &is_inout
))
743 && REG_P (DECL_RTL (val
))
744 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
))))
745 lang_hooks
.mark_addressable (val
);
752 if (ninputs
+ noutputs
> MAX_RECOG_OPERANDS
)
754 error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS
);
758 for (i
= 0, tail
= inputs
; tail
; i
++, tail
= TREE_CHAIN (tail
))
760 bool allows_reg
, allows_mem
;
761 const char *constraint
;
763 /* If there's an erroneous arg, emit no insn, because the ASM_INPUT
764 would get VOIDmode and that could cause a crash in reload. */
765 if (TREE_TYPE (TREE_VALUE (tail
)) == error_mark_node
)
768 constraint
= constraints
[i
+ noutputs
];
769 if (! parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, ninout
,
770 constraints
, &allows_mem
, &allows_reg
))
773 if (! allows_reg
&& allows_mem
)
774 lang_hooks
.mark_addressable (TREE_VALUE (tail
));
777 /* Second pass evaluates arguments. */
780 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
782 tree val
= TREE_VALUE (tail
);
783 tree type
= TREE_TYPE (val
);
790 ok
= parse_output_constraint (&constraints
[i
], i
, ninputs
,
791 noutputs
, &allows_mem
, &allows_reg
,
795 /* If an output operand is not a decl or indirect ref and our constraint
796 allows a register, make a temporary to act as an intermediate.
797 Make the asm insn write into that, then our caller will copy it to
798 the real output operand. Likewise for promoted variables. */
800 generating_concat_p
= 0;
802 real_output_rtx
[i
] = NULL_RTX
;
803 if ((TREE_CODE (val
) == INDIRECT_REF
806 && (allows_mem
|| REG_P (DECL_RTL (val
)))
807 && ! (REG_P (DECL_RTL (val
))
808 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
812 op
= expand_expr (val
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
814 op
= validize_mem (op
);
816 if (! allows_reg
&& !MEM_P (op
))
817 error ("output number %d not directly addressable", i
);
818 if ((! allows_mem
&& MEM_P (op
))
819 || GET_CODE (op
) == CONCAT
)
821 real_output_rtx
[i
] = op
;
822 op
= gen_reg_rtx (GET_MODE (op
));
824 emit_move_insn (op
, real_output_rtx
[i
]);
829 op
= assign_temp (type
, 0, 0, 1);
830 op
= validize_mem (op
);
831 TREE_VALUE (tail
) = make_tree (type
, op
);
835 generating_concat_p
= old_generating_concat_p
;
839 inout_mode
[ninout
] = TYPE_MODE (type
);
840 inout_opnum
[ninout
++] = i
;
843 if (tree_conflicts_with_clobbers_p (val
, &clobbered_regs
))
844 clobber_conflict_found
= 1;
847 /* Make vectors for the expression-rtx, constraint strings,
848 and named operands. */
850 argvec
= rtvec_alloc (ninputs
);
851 constraintvec
= rtvec_alloc (ninputs
);
853 body
= gen_rtx_ASM_OPERANDS ((noutputs
== 0 ? VOIDmode
854 : GET_MODE (output_rtx
[0])),
855 ggc_strdup (TREE_STRING_POINTER (string
)),
856 empty_string
, 0, argvec
, constraintvec
,
859 MEM_VOLATILE_P (body
) = vol
;
861 /* Eval the inputs and put them into ARGVEC.
862 Put their constraints into ASM_INPUTs and store in CONSTRAINTS. */
864 for (i
= 0, tail
= inputs
; tail
; tail
= TREE_CHAIN (tail
), ++i
)
866 bool allows_reg
, allows_mem
;
867 const char *constraint
;
872 constraint
= constraints
[i
+ noutputs
];
873 ok
= parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, ninout
,
874 constraints
, &allows_mem
, &allows_reg
);
877 generating_concat_p
= 0;
879 val
= TREE_VALUE (tail
);
880 type
= TREE_TYPE (val
);
881 /* EXPAND_INITIALIZER will not generate code for valid initializer
882 constants, but will still generate code for other types of operand.
883 This is the behavior we want for constant constraints. */
884 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
885 allows_reg
? EXPAND_NORMAL
886 : allows_mem
? EXPAND_MEMORY
887 : EXPAND_INITIALIZER
);
889 /* Never pass a CONCAT to an ASM. */
890 if (GET_CODE (op
) == CONCAT
)
891 op
= force_reg (GET_MODE (op
), op
);
893 op
= validize_mem (op
);
895 if (asm_operand_ok (op
, constraint
) <= 0)
897 if (allows_reg
&& TYPE_MODE (type
) != BLKmode
)
898 op
= force_reg (TYPE_MODE (type
), op
);
899 else if (!allows_mem
)
900 warning (0, "asm operand %d probably doesn%'t match constraints",
904 /* We won't recognize either volatile memory or memory
905 with a queued address as available a memory_operand
906 at this point. Ignore it: clearly this *is* a memory. */
910 warning (0, "use of memory input without lvalue in "
911 "asm operand %d is deprecated", i
+ noutputs
);
915 rtx mem
= force_const_mem (TYPE_MODE (type
), op
);
917 op
= validize_mem (mem
);
919 op
= force_reg (TYPE_MODE (type
), op
);
922 || GET_CODE (op
) == SUBREG
923 || GET_CODE (op
) == CONCAT
)
925 tree qual_type
= build_qualified_type (type
,
928 rtx memloc
= assign_temp (qual_type
, 1, 1, 1);
929 memloc
= validize_mem (memloc
);
930 emit_move_insn (memloc
, op
);
936 generating_concat_p
= old_generating_concat_p
;
937 ASM_OPERANDS_INPUT (body
, i
) = op
;
939 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, i
)
940 = gen_rtx_ASM_INPUT (TYPE_MODE (type
),
941 ggc_strdup (constraints
[i
+ noutputs
]));
943 if (tree_conflicts_with_clobbers_p (val
, &clobbered_regs
))
944 clobber_conflict_found
= 1;
947 /* Protect all the operands from the queue now that they have all been
950 generating_concat_p
= 0;
952 /* For in-out operands, copy output rtx to input rtx. */
953 for (i
= 0; i
< ninout
; i
++)
955 int j
= inout_opnum
[i
];
958 ASM_OPERANDS_INPUT (body
, ninputs
- ninout
+ i
)
961 sprintf (buffer
, "%d", j
);
962 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, ninputs
- ninout
+ i
)
963 = gen_rtx_ASM_INPUT (inout_mode
[i
], ggc_strdup (buffer
));
966 generating_concat_p
= old_generating_concat_p
;
968 /* Now, for each output, construct an rtx
969 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
970 ARGVEC CONSTRAINTS OPNAMES))
971 If there is more than one, put them inside a PARALLEL. */
973 if (noutputs
== 1 && nclobbers
== 0)
975 ASM_OPERANDS_OUTPUT_CONSTRAINT (body
) = ggc_strdup (constraints
[0]);
976 emit_insn (gen_rtx_SET (VOIDmode
, output_rtx
[0], body
));
979 else if (noutputs
== 0 && nclobbers
== 0)
981 /* No output operands: put in a raw ASM_OPERANDS rtx. */
993 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
995 /* For each output operand, store a SET. */
996 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
999 = gen_rtx_SET (VOIDmode
,
1001 gen_rtx_ASM_OPERANDS
1002 (GET_MODE (output_rtx
[i
]),
1003 ggc_strdup (TREE_STRING_POINTER (string
)),
1004 ggc_strdup (constraints
[i
]),
1005 i
, argvec
, constraintvec
, locus
));
1007 MEM_VOLATILE_P (SET_SRC (XVECEXP (body
, 0, i
))) = vol
;
1010 /* If there are no outputs (but there are some clobbers)
1011 store the bare ASM_OPERANDS into the PARALLEL. */
1014 XVECEXP (body
, 0, i
++) = obody
;
1016 /* Store (clobber REG) for each clobbered register specified. */
1018 for (tail
= clobbers
; tail
; tail
= TREE_CHAIN (tail
))
1020 const char *regname
= TREE_STRING_POINTER (TREE_VALUE (tail
));
1021 int j
= decode_reg_name (regname
);
1026 if (j
== -3) /* `cc', which is not a register */
1029 if (j
== -4) /* `memory', don't cache memory across asm */
1031 XVECEXP (body
, 0, i
++)
1032 = gen_rtx_CLOBBER (VOIDmode
,
1035 gen_rtx_SCRATCH (VOIDmode
)));
1039 /* Ignore unknown register, error already signaled. */
1043 /* Use QImode since that's guaranteed to clobber just one reg. */
1044 clobbered_reg
= gen_rtx_REG (QImode
, j
);
1046 /* Do sanity check for overlap between clobbers and respectively
1047 input and outputs that hasn't been handled. Such overlap
1048 should have been detected and reported above. */
1049 if (!clobber_conflict_found
)
1053 /* We test the old body (obody) contents to avoid tripping
1054 over the under-construction body. */
1055 for (opno
= 0; opno
< noutputs
; opno
++)
1056 if (reg_overlap_mentioned_p (clobbered_reg
, output_rtx
[opno
]))
1057 internal_error ("asm clobber conflict with output operand");
1059 for (opno
= 0; opno
< ninputs
- ninout
; opno
++)
1060 if (reg_overlap_mentioned_p (clobbered_reg
,
1061 ASM_OPERANDS_INPUT (obody
, opno
)))
1062 internal_error ("asm clobber conflict with input operand");
1065 XVECEXP (body
, 0, i
++)
1066 = gen_rtx_CLOBBER (VOIDmode
, clobbered_reg
);
1072 /* For any outputs that needed reloading into registers, spill them
1073 back to where they belong. */
1074 for (i
= 0; i
< noutputs
; ++i
)
1075 if (real_output_rtx
[i
])
1076 emit_move_insn (real_output_rtx
[i
], output_rtx
[i
]);
1078 crtl
->has_asm_statement
= 1;
1083 expand_asm_expr (tree exp
)
1089 if (ASM_INPUT_P (exp
))
1091 expand_asm_loc (ASM_STRING (exp
), ASM_VOLATILE_P (exp
), input_location
);
1095 outputs
= ASM_OUTPUTS (exp
);
1096 noutputs
= list_length (outputs
);
1097 /* o[I] is the place that output number I should be written. */
1098 o
= (tree
*) alloca (noutputs
* sizeof (tree
));
1100 /* Record the contents of OUTPUTS before it is modified. */
1101 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
1102 o
[i
] = TREE_VALUE (tail
);
1104 /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
1105 OUTPUTS some trees for where the values were actually stored. */
1106 expand_asm_operands (ASM_STRING (exp
), outputs
, ASM_INPUTS (exp
),
1107 ASM_CLOBBERS (exp
), ASM_VOLATILE_P (exp
),
1110 /* Copy all the intermediate outputs into the specified outputs. */
1111 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
1113 if (o
[i
] != TREE_VALUE (tail
))
1115 expand_assignment (o
[i
], TREE_VALUE (tail
), false);
1118 /* Restore the original value so that it's correct the next
1119 time we expand this function. */
1120 TREE_VALUE (tail
) = o
[i
];
1125 /* A subroutine of expand_asm_operands. Check that all operands have
1126 the same number of alternatives. Return true if so. */
1129 check_operand_nalternatives (tree outputs
, tree inputs
)
1131 if (outputs
|| inputs
)
1133 tree tmp
= TREE_PURPOSE (outputs
? outputs
: inputs
);
1135 = n_occurrences (',', TREE_STRING_POINTER (TREE_VALUE (tmp
)));
1138 if (nalternatives
+ 1 > MAX_RECOG_ALTERNATIVES
)
1140 error ("too many alternatives in %<asm%>");
1147 const char *constraint
1148 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tmp
)));
1150 if (n_occurrences (',', constraint
) != nalternatives
)
1152 error ("operand constraints for %<asm%> differ "
1153 "in number of alternatives");
1157 if (TREE_CHAIN (tmp
))
1158 tmp
= TREE_CHAIN (tmp
);
1160 tmp
= next
, next
= 0;
1167 /* A subroutine of expand_asm_operands. Check that all operand names
1168 are unique. Return true if so. We rely on the fact that these names
1169 are identifiers, and so have been canonicalized by get_identifier,
1170 so all we need are pointer comparisons. */
1173 check_unique_operand_names (tree outputs
, tree inputs
)
1177 for (i
= outputs
; i
; i
= TREE_CHAIN (i
))
1179 tree i_name
= TREE_PURPOSE (TREE_PURPOSE (i
));
1183 for (j
= TREE_CHAIN (i
); j
; j
= TREE_CHAIN (j
))
1184 if (simple_cst_equal (i_name
, TREE_PURPOSE (TREE_PURPOSE (j
))))
1188 for (i
= inputs
; i
; i
= TREE_CHAIN (i
))
1190 tree i_name
= TREE_PURPOSE (TREE_PURPOSE (i
));
1194 for (j
= TREE_CHAIN (i
); j
; j
= TREE_CHAIN (j
))
1195 if (simple_cst_equal (i_name
, TREE_PURPOSE (TREE_PURPOSE (j
))))
1197 for (j
= outputs
; j
; j
= TREE_CHAIN (j
))
1198 if (simple_cst_equal (i_name
, TREE_PURPOSE (TREE_PURPOSE (j
))))
1205 error ("duplicate asm operand name %qs",
1206 TREE_STRING_POINTER (TREE_PURPOSE (TREE_PURPOSE (i
))));
1210 /* A subroutine of expand_asm_operands. Resolve the names of the operands
1211 in *POUTPUTS and *PINPUTS to numbers, and replace the name expansions in
1212 STRING and in the constraints to those numbers. */
1215 resolve_asm_operand_names (tree string
, tree outputs
, tree inputs
)
1222 check_unique_operand_names (outputs
, inputs
);
1224 /* Substitute [<name>] in input constraint strings. There should be no
1225 named operands in output constraints. */
1226 for (t
= inputs
; t
; t
= TREE_CHAIN (t
))
1228 c
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1229 if (strchr (c
, '[') != NULL
)
1231 p
= buffer
= xstrdup (c
);
1232 while ((p
= strchr (p
, '[')) != NULL
)
1233 p
= resolve_operand_name_1 (p
, outputs
, inputs
);
1234 TREE_VALUE (TREE_PURPOSE (t
))
1235 = build_string (strlen (buffer
), buffer
);
1240 /* Now check for any needed substitutions in the template. */
1241 c
= TREE_STRING_POINTER (string
);
1242 while ((c
= strchr (c
, '%')) != NULL
)
1246 else if (ISALPHA (c
[1]) && c
[2] == '[')
1257 /* OK, we need to make a copy so we can perform the substitutions.
1258 Assume that we will not need extra space--we get to remove '['
1259 and ']', which means we cannot have a problem until we have more
1260 than 999 operands. */
1261 buffer
= xstrdup (TREE_STRING_POINTER (string
));
1262 p
= buffer
+ (c
- TREE_STRING_POINTER (string
));
1264 while ((p
= strchr (p
, '%')) != NULL
)
1268 else if (ISALPHA (p
[1]) && p
[2] == '[')
1276 p
= resolve_operand_name_1 (p
, outputs
, inputs
);
1279 string
= build_string (strlen (buffer
), buffer
);
1286 /* A subroutine of resolve_operand_names. P points to the '[' for a
1287 potential named operand of the form [<name>]. In place, replace
1288 the name and brackets with a number. Return a pointer to the
1289 balance of the string after substitution. */
1292 resolve_operand_name_1 (char *p
, tree outputs
, tree inputs
)
1299 /* Collect the operand name. */
1300 q
= strchr (p
, ']');
1303 error ("missing close brace for named operand");
1304 return strchr (p
, '\0');
1308 /* Resolve the name to a number. */
1309 for (op
= 0, t
= outputs
; t
; t
= TREE_CHAIN (t
), op
++)
1311 tree name
= TREE_PURPOSE (TREE_PURPOSE (t
));
1314 const char *c
= TREE_STRING_POINTER (name
);
1315 if (strncmp (c
, p
+ 1, len
) == 0 && c
[len
] == '\0')
1319 for (t
= inputs
; t
; t
= TREE_CHAIN (t
), op
++)
1321 tree name
= TREE_PURPOSE (TREE_PURPOSE (t
));
1324 const char *c
= TREE_STRING_POINTER (name
);
1325 if (strncmp (c
, p
+ 1, len
) == 0 && c
[len
] == '\0')
1331 error ("undefined named operand %qs", p
+ 1);
1335 /* Replace the name with the number. Unfortunately, not all libraries
1336 get the return value of sprintf correct, so search for the end of the
1337 generated string by hand. */
1338 sprintf (p
, "%d", op
);
1339 p
= strchr (p
, '\0');
1341 /* Verify the no extra buffer space assumption. */
1342 gcc_assert (p
<= q
);
1344 /* Shift the rest of the buffer down to fill the gap. */
1345 memmove (p
, q
+ 1, strlen (q
+ 1) + 1);
1350 /* Generate RTL to evaluate the expression EXP. */
1353 expand_expr_stmt (tree exp
)
1358 value
= expand_expr (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
1359 type
= TREE_TYPE (exp
);
1361 /* If all we do is reference a volatile value in memory,
1362 copy it to a register to be sure it is actually touched. */
1363 if (value
&& MEM_P (value
) && TREE_THIS_VOLATILE (exp
))
1365 if (TYPE_MODE (type
) == VOIDmode
)
1367 else if (TYPE_MODE (type
) != BLKmode
)
1368 value
= copy_to_reg (value
);
1371 rtx lab
= gen_label_rtx ();
1373 /* Compare the value with itself to reference it. */
1374 emit_cmp_and_jump_insns (value
, value
, EQ
,
1375 expand_normal (TYPE_SIZE (type
)),
1381 /* Free any temporaries used to evaluate this expression. */
1385 /* Warn if EXP contains any computations whose results are not used.
1386 Return 1 if a warning is printed; 0 otherwise. LOCUS is the
1387 (potential) location of the expression. */
1390 warn_if_unused_value (const_tree exp
, location_t locus
)
1393 if (TREE_USED (exp
) || TREE_NO_WARNING (exp
))
1396 /* Don't warn about void constructs. This includes casting to void,
1397 void function calls, and statement expressions with a final cast
1399 if (VOID_TYPE_P (TREE_TYPE (exp
)))
1402 if (EXPR_HAS_LOCATION (exp
))
1403 locus
= EXPR_LOCATION (exp
);
1405 switch (TREE_CODE (exp
))
1407 case PREINCREMENT_EXPR
:
1408 case POSTINCREMENT_EXPR
:
1409 case PREDECREMENT_EXPR
:
1410 case POSTDECREMENT_EXPR
:
1415 case TRY_CATCH_EXPR
:
1416 case WITH_CLEANUP_EXPR
:
1422 /* For a binding, warn if no side effect within it. */
1423 exp
= BIND_EXPR_BODY (exp
);
1427 exp
= TREE_OPERAND (exp
, 0);
1430 case TRUTH_ORIF_EXPR
:
1431 case TRUTH_ANDIF_EXPR
:
1432 /* In && or ||, warn if 2nd operand has no side effect. */
1433 exp
= TREE_OPERAND (exp
, 1);
1437 if (warn_if_unused_value (TREE_OPERAND (exp
, 0), locus
))
1439 /* Let people do `(foo (), 0)' without a warning. */
1440 if (TREE_CONSTANT (TREE_OPERAND (exp
, 1)))
1442 exp
= TREE_OPERAND (exp
, 1);
1446 /* If this is an expression with side effects, don't warn; this
1447 case commonly appears in macro expansions. */
1448 if (TREE_SIDE_EFFECTS (exp
))
1453 /* Don't warn about automatic dereferencing of references, since
1454 the user cannot control it. */
1455 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == REFERENCE_TYPE
)
1457 exp
= TREE_OPERAND (exp
, 0);
1463 /* Referencing a volatile value is a side effect, so don't warn. */
1464 if ((DECL_P (exp
) || REFERENCE_CLASS_P (exp
))
1465 && TREE_THIS_VOLATILE (exp
))
1468 /* If this is an expression which has no operands, there is no value
1469 to be unused. There are no such language-independent codes,
1470 but front ends may define such. */
1471 if (EXPRESSION_CLASS_P (exp
) && TREE_OPERAND_LENGTH (exp
) == 0)
1475 warning (OPT_Wunused_value
, "%Hvalue computed is not used", &locus
);
1481 /* Generate RTL to return from the current function, with no value.
1482 (That is, we do not do anything about returning any value.) */
1485 expand_null_return (void)
1487 /* If this function was declared to return a value, but we
1488 didn't, clobber the return registers so that they are not
1489 propagated live to the rest of the function. */
1490 clobber_return_register ();
1492 expand_null_return_1 ();
1495 /* Generate RTL to return directly from the current function.
1496 (That is, we bypass any return value.) */
1499 expand_naked_return (void)
1503 clear_pending_stack_adjust ();
1504 do_pending_stack_adjust ();
1506 end_label
= naked_return_label
;
1508 end_label
= naked_return_label
= gen_label_rtx ();
1510 emit_jump (end_label
);
1513 /* Generate RTL to return from the current function, with value VAL. */
1516 expand_value_return (rtx val
)
1518 /* Copy the value to the return location
1519 unless it's already there. */
1521 rtx return_reg
= DECL_RTL (DECL_RESULT (current_function_decl
));
1522 if (return_reg
!= val
)
1524 tree type
= TREE_TYPE (DECL_RESULT (current_function_decl
));
1525 if (targetm
.calls
.promote_function_return (TREE_TYPE (current_function_decl
)))
1527 int unsignedp
= TYPE_UNSIGNED (type
);
1528 enum machine_mode old_mode
1529 = DECL_MODE (DECL_RESULT (current_function_decl
));
1530 enum machine_mode mode
1531 = promote_mode (type
, old_mode
, &unsignedp
, 1);
1533 if (mode
!= old_mode
)
1534 val
= convert_modes (mode
, old_mode
, val
, unsignedp
);
1536 if (GET_CODE (return_reg
) == PARALLEL
)
1537 emit_group_load (return_reg
, val
, type
, int_size_in_bytes (type
));
1539 emit_move_insn (return_reg
, val
);
1542 expand_null_return_1 ();
1545 /* Output a return with no value. */
1548 expand_null_return_1 (void)
1550 clear_pending_stack_adjust ();
1551 do_pending_stack_adjust ();
1552 emit_jump (return_label
);
1555 /* Generate RTL to evaluate the expression RETVAL and return it
1556 from the current function. */
1559 expand_return (tree retval
)
1565 /* If function wants no value, give it none. */
1566 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl
))) == VOID_TYPE
)
1568 expand_normal (retval
);
1569 expand_null_return ();
1573 if (retval
== error_mark_node
)
1575 /* Treat this like a return of no value from a function that
1577 expand_null_return ();
1580 else if ((TREE_CODE (retval
) == MODIFY_EXPR
1581 || TREE_CODE (retval
) == INIT_EXPR
)
1582 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
1583 retval_rhs
= TREE_OPERAND (retval
, 1);
1585 retval_rhs
= retval
;
1587 result_rtl
= DECL_RTL (DECL_RESULT (current_function_decl
));
1589 /* If we are returning the RESULT_DECL, then the value has already
1590 been stored into it, so we don't have to do anything special. */
1591 if (TREE_CODE (retval_rhs
) == RESULT_DECL
)
1592 expand_value_return (result_rtl
);
1594 /* If the result is an aggregate that is being returned in one (or more)
1595 registers, load the registers here. The compiler currently can't handle
1596 copying a BLKmode value into registers. We could put this code in a
1597 more general area (for use by everyone instead of just function
1598 call/return), but until this feature is generally usable it is kept here
1599 (and in expand_call). */
1601 else if (retval_rhs
!= 0
1602 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
1603 && REG_P (result_rtl
))
1606 unsigned HOST_WIDE_INT bitpos
, xbitpos
;
1607 unsigned HOST_WIDE_INT padding_correction
= 0;
1608 unsigned HOST_WIDE_INT bytes
1609 = int_size_in_bytes (TREE_TYPE (retval_rhs
));
1610 int n_regs
= (bytes
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
1611 unsigned int bitsize
1612 = MIN (TYPE_ALIGN (TREE_TYPE (retval_rhs
)), BITS_PER_WORD
);
1613 rtx
*result_pseudos
= XALLOCAVEC (rtx
, n_regs
);
1614 rtx result_reg
, src
= NULL_RTX
, dst
= NULL_RTX
;
1615 rtx result_val
= expand_normal (retval_rhs
);
1616 enum machine_mode tmpmode
, result_reg_mode
;
1620 expand_null_return ();
1624 /* If the structure doesn't take up a whole number of words, see
1625 whether the register value should be padded on the left or on
1626 the right. Set PADDING_CORRECTION to the number of padding
1627 bits needed on the left side.
1629 In most ABIs, the structure will be returned at the least end of
1630 the register, which translates to right padding on little-endian
1631 targets and left padding on big-endian targets. The opposite
1632 holds if the structure is returned at the most significant
1633 end of the register. */
1634 if (bytes
% UNITS_PER_WORD
!= 0
1635 && (targetm
.calls
.return_in_msb (TREE_TYPE (retval_rhs
))
1637 : BYTES_BIG_ENDIAN
))
1638 padding_correction
= (BITS_PER_WORD
- ((bytes
% UNITS_PER_WORD
)
1641 /* Copy the structure BITSIZE bits at a time. */
1642 for (bitpos
= 0, xbitpos
= padding_correction
;
1643 bitpos
< bytes
* BITS_PER_UNIT
;
1644 bitpos
+= bitsize
, xbitpos
+= bitsize
)
1646 /* We need a new destination pseudo each time xbitpos is
1647 on a word boundary and when xbitpos == padding_correction
1648 (the first time through). */
1649 if (xbitpos
% BITS_PER_WORD
== 0
1650 || xbitpos
== padding_correction
)
1652 /* Generate an appropriate register. */
1653 dst
= gen_reg_rtx (word_mode
);
1654 result_pseudos
[xbitpos
/ BITS_PER_WORD
] = dst
;
1656 /* Clear the destination before we move anything into it. */
1657 emit_move_insn (dst
, CONST0_RTX (GET_MODE (dst
)));
1660 /* We need a new source operand each time bitpos is on a word
1662 if (bitpos
% BITS_PER_WORD
== 0)
1663 src
= operand_subword_force (result_val
,
1664 bitpos
/ BITS_PER_WORD
,
1667 /* Use bitpos for the source extraction (left justified) and
1668 xbitpos for the destination store (right justified). */
1669 store_bit_field (dst
, bitsize
, xbitpos
% BITS_PER_WORD
, word_mode
,
1670 extract_bit_field (src
, bitsize
,
1671 bitpos
% BITS_PER_WORD
, 1,
1672 NULL_RTX
, word_mode
, word_mode
));
1675 tmpmode
= GET_MODE (result_rtl
);
1676 if (tmpmode
== BLKmode
)
1678 /* Find the smallest integer mode large enough to hold the
1679 entire structure and use that mode instead of BLKmode
1680 on the USE insn for the return register. */
1681 for (tmpmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
1682 tmpmode
!= VOIDmode
;
1683 tmpmode
= GET_MODE_WIDER_MODE (tmpmode
))
1684 /* Have we found a large enough mode? */
1685 if (GET_MODE_SIZE (tmpmode
) >= bytes
)
1688 /* A suitable mode should have been found. */
1689 gcc_assert (tmpmode
!= VOIDmode
);
1691 PUT_MODE (result_rtl
, tmpmode
);
1694 if (GET_MODE_SIZE (tmpmode
) < GET_MODE_SIZE (word_mode
))
1695 result_reg_mode
= word_mode
;
1697 result_reg_mode
= tmpmode
;
1698 result_reg
= gen_reg_rtx (result_reg_mode
);
1700 for (i
= 0; i
< n_regs
; i
++)
1701 emit_move_insn (operand_subword (result_reg
, i
, 0, result_reg_mode
),
1704 if (tmpmode
!= result_reg_mode
)
1705 result_reg
= gen_lowpart (tmpmode
, result_reg
);
1707 expand_value_return (result_reg
);
1709 else if (retval_rhs
!= 0
1710 && !VOID_TYPE_P (TREE_TYPE (retval_rhs
))
1711 && (REG_P (result_rtl
)
1712 || (GET_CODE (result_rtl
) == PARALLEL
)))
1714 /* Calculate the return value into a temporary (usually a pseudo
1716 tree ot
= TREE_TYPE (DECL_RESULT (current_function_decl
));
1717 tree nt
= build_qualified_type (ot
, TYPE_QUALS (ot
) | TYPE_QUAL_CONST
);
1719 val
= assign_temp (nt
, 0, 0, 1);
1720 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), EXPAND_NORMAL
);
1721 val
= force_not_mem (val
);
1722 /* Return the calculated value. */
1723 expand_value_return (val
);
1727 /* No hard reg used; calculate value into hard return reg. */
1728 expand_expr (retval
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
1729 expand_value_return (result_rtl
);
1733 /* Given a pointer to a BLOCK node return nonzero if (and only if) the node
1734 in question represents the outermost pair of curly braces (i.e. the "body
1735 block") of a function or method.
1737 For any BLOCK node representing a "body block" of a function or method, the
1738 BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which
1739 represents the outermost (function) scope for the function or method (i.e.
1740 the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of
1741 *that* node in turn will point to the relevant FUNCTION_DECL node. */
1744 is_body_block (const_tree stmt
)
1746 if (lang_hooks
.no_body_blocks
)
1749 if (TREE_CODE (stmt
) == BLOCK
)
1751 tree parent
= BLOCK_SUPERCONTEXT (stmt
);
1753 if (parent
&& TREE_CODE (parent
) == BLOCK
)
1755 tree grandparent
= BLOCK_SUPERCONTEXT (parent
);
1757 if (grandparent
&& TREE_CODE (grandparent
) == FUNCTION_DECL
)
1765 /* Emit code to restore vital registers at the beginning of a nonlocal goto
1768 expand_nl_goto_receiver (void)
1770 /* Clobber the FP when we get here, so we have to make sure it's
1771 marked as used by this function. */
1772 emit_use (hard_frame_pointer_rtx
);
1774 /* Mark the static chain as clobbered here so life information
1775 doesn't get messed up for it. */
1776 emit_clobber (static_chain_rtx
);
1778 #ifdef HAVE_nonlocal_goto
1779 if (! HAVE_nonlocal_goto
)
1781 /* First adjust our frame pointer to its actual value. It was
1782 previously set to the start of the virtual area corresponding to
1783 the stacked variables when we branched here and now needs to be
1784 adjusted to the actual hardware fp value.
1786 Assignments are to virtual registers are converted by
1787 instantiate_virtual_regs into the corresponding assignment
1788 to the underlying register (fp in this case) that makes
1789 the original assignment true.
1790 So the following insn will actually be
1791 decrementing fp by STARTING_FRAME_OFFSET. */
1792 emit_move_insn (virtual_stack_vars_rtx
, hard_frame_pointer_rtx
);
1794 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
1795 if (fixed_regs
[ARG_POINTER_REGNUM
])
1797 #ifdef ELIMINABLE_REGS
1798 /* If the argument pointer can be eliminated in favor of the
1799 frame pointer, we don't need to restore it. We assume here
1800 that if such an elimination is present, it can always be used.
1801 This is the case on all known machines; if we don't make this
1802 assumption, we do unnecessary saving on many machines. */
1803 static const struct elims
{const int from
, to
;} elim_regs
[] = ELIMINABLE_REGS
;
1806 for (i
= 0; i
< ARRAY_SIZE (elim_regs
); i
++)
1807 if (elim_regs
[i
].from
== ARG_POINTER_REGNUM
1808 && elim_regs
[i
].to
== HARD_FRAME_POINTER_REGNUM
)
1811 if (i
== ARRAY_SIZE (elim_regs
))
1814 /* Now restore our arg pointer from the address at which it
1815 was saved in our stack frame. */
1816 emit_move_insn (crtl
->args
.internal_arg_pointer
,
1817 copy_to_reg (get_arg_pointer_save_area ()));
1822 #ifdef HAVE_nonlocal_goto_receiver
1823 if (HAVE_nonlocal_goto_receiver
)
1824 emit_insn (gen_nonlocal_goto_receiver ());
1827 /* We must not allow the code we just generated to be reordered by
1828 scheduling. Specifically, the update of the frame pointer must
1829 happen immediately, not later. */
1830 emit_insn (gen_blockage ());
1833 /* Generate RTL for the automatic variable declaration DECL.
1834 (Other kinds of declarations are simply ignored if seen here.) */
1837 expand_decl (tree decl
)
1841 type
= TREE_TYPE (decl
);
1843 /* For a CONST_DECL, set mode, alignment, and sizes from those of the
1844 type in case this node is used in a reference. */
1845 if (TREE_CODE (decl
) == CONST_DECL
)
1847 DECL_MODE (decl
) = TYPE_MODE (type
);
1848 DECL_ALIGN (decl
) = TYPE_ALIGN (type
);
1849 DECL_SIZE (decl
) = TYPE_SIZE (type
);
1850 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (type
);
1854 /* Otherwise, only automatic variables need any expansion done. Static and
1855 external variables, and external functions, will be handled by
1856 `assemble_variable' (called from finish_decl). TYPE_DECL requires
1857 nothing. PARM_DECLs are handled in `assign_parms'. */
1858 if (TREE_CODE (decl
) != VAR_DECL
)
1861 if (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
))
1864 /* Create the RTL representation for the variable. */
1866 if (type
== error_mark_node
)
1867 SET_DECL_RTL (decl
, gen_rtx_MEM (BLKmode
, const0_rtx
));
1869 else if (DECL_SIZE (decl
) == 0)
1871 /* Variable with incomplete type. */
1873 if (DECL_INITIAL (decl
) == 0)
1874 /* Error message was already done; now avoid a crash. */
1875 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
1877 /* An initializer is going to decide the size of this array.
1878 Until we know the size, represent its address with a reg. */
1879 x
= gen_rtx_MEM (BLKmode
, gen_reg_rtx (Pmode
));
1881 set_mem_attributes (x
, decl
, 1);
1882 SET_DECL_RTL (decl
, x
);
1884 else if (use_register_for_decl (decl
))
1886 /* Automatic variable that can go in a register. */
1887 int unsignedp
= TYPE_UNSIGNED (type
);
1888 enum machine_mode reg_mode
1889 = promote_mode (type
, DECL_MODE (decl
), &unsignedp
, 0);
1891 SET_DECL_RTL (decl
, gen_reg_rtx (reg_mode
));
1893 /* Note if the object is a user variable. */
1894 if (!DECL_ARTIFICIAL (decl
))
1895 mark_user_reg (DECL_RTL (decl
));
1897 if (POINTER_TYPE_P (type
))
1898 mark_reg_pointer (DECL_RTL (decl
),
1899 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl
))));
1908 /* Variable-sized decls are dealt with in the gimplifier. */
1909 gcc_assert (TREE_CODE (DECL_SIZE_UNIT (decl
)) == INTEGER_CST
);
1911 /* If we previously made RTL for this decl, it must be an array
1912 whose size was determined by the initializer.
1913 The old address was a register; set that register now
1914 to the proper address. */
1915 if (DECL_RTL_SET_P (decl
))
1917 gcc_assert (MEM_P (DECL_RTL (decl
)));
1918 gcc_assert (REG_P (XEXP (DECL_RTL (decl
), 0)));
1919 oldaddr
= XEXP (DECL_RTL (decl
), 0);
1922 /* Set alignment we actually gave this decl. */
1923 DECL_ALIGN (decl
) = (DECL_MODE (decl
) == BLKmode
? BIGGEST_ALIGNMENT
1924 : GET_MODE_BITSIZE (DECL_MODE (decl
)));
1925 DECL_USER_ALIGN (decl
) = 0;
1927 x
= assign_temp (decl
, 1, 1, 1);
1928 set_mem_attributes (x
, decl
, 1);
1929 SET_DECL_RTL (decl
, x
);
1933 addr
= force_operand (XEXP (DECL_RTL (decl
), 0), oldaddr
);
1934 if (addr
!= oldaddr
)
1935 emit_move_insn (oldaddr
, addr
);
1940 /* Emit code to save the current value of stack. */
1942 expand_stack_save (void)
1946 do_pending_stack_adjust ();
1947 emit_stack_save (SAVE_BLOCK
, &ret
, NULL_RTX
);
1951 /* Emit code to restore the current value of stack. */
1953 expand_stack_restore (tree var
)
1955 rtx sa
= expand_normal (var
);
1957 sa
= convert_memory_address (Pmode
, sa
);
1958 emit_stack_restore (SAVE_BLOCK
, sa
, NULL_RTX
);
1961 /* Do the insertion of a case label into case_list. The labels are
1962 fed to us in descending order from the sorted vector of case labels used
1963 in the tree part of the middle end. So the list we construct is
1964 sorted in ascending order. The bounds on the case range, LOW and HIGH,
1965 are converted to case's index type TYPE. */
1967 static struct case_node
*
1968 add_case_node (struct case_node
*head
, tree type
, tree low
, tree high
,
1969 tree label
, alloc_pool case_node_pool
)
1971 tree min_value
, max_value
;
1972 struct case_node
*r
;
1974 gcc_assert (TREE_CODE (low
) == INTEGER_CST
);
1975 gcc_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
1977 min_value
= TYPE_MIN_VALUE (type
);
1978 max_value
= TYPE_MAX_VALUE (type
);
1980 /* If there's no HIGH value, then this is not a case range; it's
1981 just a simple case label. But that's just a degenerate case
1983 If the bounds are equal, turn this into the one-value case. */
1984 if (!high
|| tree_int_cst_equal (low
, high
))
1986 /* If the simple case value is unreachable, ignore it. */
1987 if ((TREE_CODE (min_value
) == INTEGER_CST
1988 && tree_int_cst_compare (low
, min_value
) < 0)
1989 || (TREE_CODE (max_value
) == INTEGER_CST
1990 && tree_int_cst_compare (low
, max_value
) > 0))
1992 low
= fold_convert (type
, low
);
1997 /* If the entire case range is unreachable, ignore it. */
1998 if ((TREE_CODE (min_value
) == INTEGER_CST
1999 && tree_int_cst_compare (high
, min_value
) < 0)
2000 || (TREE_CODE (max_value
) == INTEGER_CST
2001 && tree_int_cst_compare (low
, max_value
) > 0))
2004 /* If the lower bound is less than the index type's minimum
2005 value, truncate the range bounds. */
2006 if (TREE_CODE (min_value
) == INTEGER_CST
2007 && tree_int_cst_compare (low
, min_value
) < 0)
2009 low
= fold_convert (type
, low
);
2011 /* If the upper bound is greater than the index type's maximum
2012 value, truncate the range bounds. */
2013 if (TREE_CODE (max_value
) == INTEGER_CST
2014 && tree_int_cst_compare (high
, max_value
) > 0)
2016 high
= fold_convert (type
, high
);
2020 /* Add this label to the chain. Make sure to drop overflow flags. */
2021 r
= (struct case_node
*) pool_alloc (case_node_pool
);
2022 r
->low
= build_int_cst_wide (TREE_TYPE (low
), TREE_INT_CST_LOW (low
),
2023 TREE_INT_CST_HIGH (low
));
2024 r
->high
= build_int_cst_wide (TREE_TYPE (high
), TREE_INT_CST_LOW (high
),
2025 TREE_INT_CST_HIGH (high
));
2026 r
->code_label
= label
;
2027 r
->parent
= r
->left
= NULL
;
2032 /* Maximum number of case bit tests. */
2033 #define MAX_CASE_BIT_TESTS 3
2035 /* By default, enable case bit tests on targets with ashlsi3. */
2036 #ifndef CASE_USE_BIT_TESTS
2037 #define CASE_USE_BIT_TESTS (optab_handler (ashl_optab, word_mode)->insn_code \
2038 != CODE_FOR_nothing)
2042 /* A case_bit_test represents a set of case nodes that may be
2043 selected from using a bit-wise comparison. HI and LO hold
2044 the integer to be tested against, LABEL contains the label
2045 to jump to upon success and BITS counts the number of case
2046 nodes handled by this test, typically the number of bits
2049 struct case_bit_test
2057 /* Determine whether "1 << x" is relatively cheap in word_mode. */
2060 bool lshift_cheap_p (void)
2062 static bool init
= false;
2063 static bool cheap
= true;
2067 rtx reg
= gen_rtx_REG (word_mode
, 10000);
2068 int cost
= rtx_cost (gen_rtx_ASHIFT (word_mode
, const1_rtx
, reg
), SET
,
2069 optimize_insn_for_speed_p ());
2070 cheap
= cost
< COSTS_N_INSNS (3);
2077 /* Comparison function for qsort to order bit tests by decreasing
2078 number of case nodes, i.e. the node with the most cases gets
2082 case_bit_test_cmp (const void *p1
, const void *p2
)
2084 const struct case_bit_test
*const d1
= (const struct case_bit_test
*) p1
;
2085 const struct case_bit_test
*const d2
= (const struct case_bit_test
*) p2
;
2087 if (d2
->bits
!= d1
->bits
)
2088 return d2
->bits
- d1
->bits
;
2090 /* Stabilize the sort. */
2091 return CODE_LABEL_NUMBER (d2
->label
) - CODE_LABEL_NUMBER (d1
->label
);
2094 /* Expand a switch statement by a short sequence of bit-wise
2095 comparisons. "switch(x)" is effectively converted into
2096 "if ((1 << (x-MINVAL)) & CST)" where CST and MINVAL are
2099 INDEX_EXPR is the value being switched on, which is of
2100 type INDEX_TYPE. MINVAL is the lowest case value of in
2101 the case nodes, of INDEX_TYPE type, and RANGE is highest
2102 value minus MINVAL, also of type INDEX_TYPE. NODES is
2103 the set of case nodes, and DEFAULT_LABEL is the label to
2104 branch to should none of the cases match.
2106 There *MUST* be MAX_CASE_BIT_TESTS or less unique case
2110 emit_case_bit_tests (tree index_type
, tree index_expr
, tree minval
,
2111 tree range
, case_node_ptr nodes
, rtx default_label
)
2113 struct case_bit_test test
[MAX_CASE_BIT_TESTS
];
2114 enum machine_mode mode
;
2115 rtx expr
, index
, label
;
2116 unsigned int i
,j
,lo
,hi
;
2117 struct case_node
*n
;
2121 for (n
= nodes
; n
; n
= n
->right
)
2123 label
= label_rtx (n
->code_label
);
2124 for (i
= 0; i
< count
; i
++)
2125 if (label
== test
[i
].label
)
2130 gcc_assert (count
< MAX_CASE_BIT_TESTS
);
2133 test
[i
].label
= label
;
2140 lo
= tree_low_cst (fold_build2 (MINUS_EXPR
, index_type
,
2141 n
->low
, minval
), 1);
2142 hi
= tree_low_cst (fold_build2 (MINUS_EXPR
, index_type
,
2143 n
->high
, minval
), 1);
2144 for (j
= lo
; j
<= hi
; j
++)
2145 if (j
>= HOST_BITS_PER_WIDE_INT
)
2146 test
[i
].hi
|= (HOST_WIDE_INT
) 1 << (j
- HOST_BITS_PER_INT
);
2148 test
[i
].lo
|= (HOST_WIDE_INT
) 1 << j
;
2151 qsort (test
, count
, sizeof(*test
), case_bit_test_cmp
);
2153 index_expr
= fold_build2 (MINUS_EXPR
, index_type
,
2154 fold_convert (index_type
, index_expr
),
2155 fold_convert (index_type
, minval
));
2156 index
= expand_normal (index_expr
);
2157 do_pending_stack_adjust ();
2159 mode
= TYPE_MODE (index_type
);
2160 expr
= expand_normal (range
);
2162 emit_cmp_and_jump_insns (index
, expr
, GTU
, NULL_RTX
, mode
, 1,
2165 index
= convert_to_mode (word_mode
, index
, 0);
2166 index
= expand_binop (word_mode
, ashl_optab
, const1_rtx
,
2167 index
, NULL_RTX
, 1, OPTAB_WIDEN
);
2169 for (i
= 0; i
< count
; i
++)
2171 expr
= immed_double_const (test
[i
].lo
, test
[i
].hi
, word_mode
);
2172 expr
= expand_binop (word_mode
, and_optab
, index
, expr
,
2173 NULL_RTX
, 1, OPTAB_WIDEN
);
2174 emit_cmp_and_jump_insns (expr
, const0_rtx
, NE
, NULL_RTX
,
2175 word_mode
, 1, test
[i
].label
);
2179 emit_jump (default_label
);
2183 #define HAVE_casesi 0
2186 #ifndef HAVE_tablejump
2187 #define HAVE_tablejump 0
2190 /* Terminate a case (Pascal/Ada) or switch (C) statement
2191 in which ORIG_INDEX is the expression to be tested.
2192 If ORIG_TYPE is not NULL, it is the original ORIG_INDEX
2193 type as given in the source before any compiler conversions.
2194 Generate the code to test it and jump to the right place. */
2197 expand_case (tree exp
)
2199 tree minval
= NULL_TREE
, maxval
= NULL_TREE
, range
= NULL_TREE
;
2200 rtx default_label
= 0;
2201 struct case_node
*n
;
2202 unsigned int count
, uniq
;
2208 rtx before_case
, end
, lab
;
2210 tree vec
= SWITCH_LABELS (exp
);
2211 tree orig_type
= TREE_TYPE (exp
);
2212 tree index_expr
= SWITCH_COND (exp
);
2213 tree index_type
= TREE_TYPE (index_expr
);
2214 int unsignedp
= TYPE_UNSIGNED (index_type
);
2216 /* The insn after which the case dispatch should finally
2217 be emitted. Zero for a dummy. */
2220 /* A list of case labels; it is first built as a list and it may then
2221 be rearranged into a nearly balanced binary tree. */
2222 struct case_node
*case_list
= 0;
2224 /* Label to jump to if no case matches. */
2225 tree default_label_decl
= NULL_TREE
;
2227 alloc_pool case_node_pool
= create_alloc_pool ("struct case_node pool",
2228 sizeof (struct case_node
),
2231 /* The switch body is lowered in gimplify.c, we should never have
2232 switches with a non-NULL SWITCH_BODY here. */
2233 gcc_assert (!SWITCH_BODY (exp
));
2234 gcc_assert (SWITCH_LABELS (exp
));
2236 do_pending_stack_adjust ();
2238 /* An ERROR_MARK occurs for various reasons including invalid data type. */
2239 if (index_type
!= error_mark_node
)
2242 bitmap label_bitmap
;
2243 int vl
= TREE_VEC_LENGTH (vec
);
2245 /* cleanup_tree_cfg removes all SWITCH_EXPR with their index
2246 expressions being INTEGER_CST. */
2247 gcc_assert (TREE_CODE (index_expr
) != INTEGER_CST
);
2249 /* The default case, if ever taken, is at the end of TREE_VEC. */
2250 elt
= TREE_VEC_ELT (vec
, vl
- 1);
2251 if (!CASE_LOW (elt
) && !CASE_HIGH (elt
))
2253 default_label_decl
= CASE_LABEL (elt
);
2257 for (i
= vl
- 1; i
>= 0; --i
)
2260 elt
= TREE_VEC_ELT (vec
, i
);
2262 low
= CASE_LOW (elt
);
2264 high
= CASE_HIGH (elt
);
2266 /* Discard empty ranges. */
2267 if (high
&& tree_int_cst_lt (high
, low
))
2270 case_list
= add_case_node (case_list
, index_type
, low
, high
,
2271 CASE_LABEL (elt
), case_node_pool
);
2275 before_case
= start
= get_last_insn ();
2276 if (default_label_decl
)
2277 default_label
= label_rtx (default_label_decl
);
2279 /* Get upper and lower bounds of case values. */
2283 label_bitmap
= BITMAP_ALLOC (NULL
);
2284 for (n
= case_list
; n
; n
= n
->right
)
2286 /* Count the elements and track the largest and smallest
2287 of them (treating them as signed even if they are not). */
2295 if (tree_int_cst_lt (n
->low
, minval
))
2297 if (tree_int_cst_lt (maxval
, n
->high
))
2300 /* A range counts double, since it requires two compares. */
2301 if (! tree_int_cst_equal (n
->low
, n
->high
))
2304 /* If we have not seen this label yet, then increase the
2305 number of unique case node targets seen. */
2306 lab
= label_rtx (n
->code_label
);
2307 if (!bitmap_bit_p (label_bitmap
, CODE_LABEL_NUMBER (lab
)))
2309 bitmap_set_bit (label_bitmap
, CODE_LABEL_NUMBER (lab
));
2314 BITMAP_FREE (label_bitmap
);
2316 /* cleanup_tree_cfg removes all SWITCH_EXPR with a single
2317 destination, such as one with a default case only. However,
2318 it doesn't remove cases that are out of range for the switch
2319 type, so we may still get a zero here. */
2323 emit_jump (default_label
);
2324 free_alloc_pool (case_node_pool
);
2328 /* Compute span of values. */
2329 range
= fold_build2 (MINUS_EXPR
, index_type
, maxval
, minval
);
2331 /* Try implementing this switch statement by a short sequence of
2332 bit-wise comparisons. However, we let the binary-tree case
2333 below handle constant index expressions. */
2334 if (CASE_USE_BIT_TESTS
2335 && ! TREE_CONSTANT (index_expr
)
2336 && compare_tree_int (range
, GET_MODE_BITSIZE (word_mode
)) < 0
2337 && compare_tree_int (range
, 0) > 0
2338 && lshift_cheap_p ()
2339 && ((uniq
== 1 && count
>= 3)
2340 || (uniq
== 2 && count
>= 5)
2341 || (uniq
== 3 && count
>= 6)))
2343 /* Optimize the case where all the case values fit in a
2344 word without having to subtract MINVAL. In this case,
2345 we can optimize away the subtraction. */
2346 if (compare_tree_int (minval
, 0) > 0
2347 && compare_tree_int (maxval
, GET_MODE_BITSIZE (word_mode
)) < 0)
2349 minval
= build_int_cst (index_type
, 0);
2352 emit_case_bit_tests (index_type
, index_expr
, minval
, range
,
2353 case_list
, default_label
);
2356 /* If range of values is much bigger than number of values,
2357 make a sequence of conditional branches instead of a dispatch.
2358 If the switch-index is a constant, do it this way
2359 because we can optimize it. */
2361 else if (count
< case_values_threshold ()
2362 || compare_tree_int (range
,
2363 (optimize_insn_for_size_p () ? 3 : 10) * count
) > 0
2364 /* RANGE may be signed, and really large ranges will show up
2365 as negative numbers. */
2366 || compare_tree_int (range
, 0) < 0
2367 #ifndef ASM_OUTPUT_ADDR_DIFF_ELT
2370 || !flag_jump_tables
2371 || TREE_CONSTANT (index_expr
)
2372 /* If neither casesi or tablejump is available, we can
2373 only go this way. */
2374 || (!HAVE_casesi
&& !HAVE_tablejump
))
2376 index
= expand_normal (index_expr
);
2378 /* If the index is a short or char that we do not have
2379 an insn to handle comparisons directly, convert it to
2380 a full integer now, rather than letting each comparison
2381 generate the conversion. */
2383 if (GET_MODE_CLASS (GET_MODE (index
)) == MODE_INT
2384 && ! have_insn_for (COMPARE
, GET_MODE (index
)))
2386 enum machine_mode wider_mode
;
2387 for (wider_mode
= GET_MODE (index
); wider_mode
!= VOIDmode
;
2388 wider_mode
= GET_MODE_WIDER_MODE (wider_mode
))
2389 if (have_insn_for (COMPARE
, wider_mode
))
2391 index
= convert_to_mode (wider_mode
, index
, unsignedp
);
2396 do_pending_stack_adjust ();
2399 index
= copy_to_reg (index
);
2401 /* We generate a binary decision tree to select the
2402 appropriate target code. This is done as follows:
2404 The list of cases is rearranged into a binary tree,
2405 nearly optimal assuming equal probability for each case.
2407 The tree is transformed into RTL, eliminating
2408 redundant test conditions at the same time.
2410 If program flow could reach the end of the
2411 decision tree an unconditional jump to the
2412 default code is emitted. */
2415 = (TREE_CODE (orig_type
) != ENUMERAL_TYPE
2416 && estimate_case_costs (case_list
));
2417 balance_case_nodes (&case_list
, NULL
);
2418 emit_case_nodes (index
, case_list
, default_label
, index_type
);
2420 emit_jump (default_label
);
2424 rtx fallback_label
= label_rtx (case_list
->code_label
);
2425 table_label
= gen_label_rtx ();
2426 if (! try_casesi (index_type
, index_expr
, minval
, range
,
2427 table_label
, default_label
, fallback_label
))
2431 /* Index jumptables from zero for suitable values of
2432 minval to avoid a subtraction. */
2433 if (optimize_insn_for_speed_p ()
2434 && compare_tree_int (minval
, 0) > 0
2435 && compare_tree_int (minval
, 3) < 0)
2437 minval
= build_int_cst (index_type
, 0);
2441 ok
= try_tablejump (index_type
, index_expr
, minval
, range
,
2442 table_label
, default_label
);
2446 /* Get table of labels to jump to, in order of case index. */
2448 ncases
= tree_low_cst (range
, 0) + 1;
2449 labelvec
= XALLOCAVEC (rtx
, ncases
);
2450 memset (labelvec
, 0, ncases
* sizeof (rtx
));
2452 for (n
= case_list
; n
; n
= n
->right
)
2454 /* Compute the low and high bounds relative to the minimum
2455 value since that should fit in a HOST_WIDE_INT while the
2456 actual values may not. */
2458 = tree_low_cst (fold_build2 (MINUS_EXPR
, index_type
,
2459 n
->low
, minval
), 1);
2460 HOST_WIDE_INT i_high
2461 = tree_low_cst (fold_build2 (MINUS_EXPR
, index_type
,
2462 n
->high
, minval
), 1);
2465 for (i
= i_low
; i
<= i_high
; i
++)
2467 = gen_rtx_LABEL_REF (Pmode
, label_rtx (n
->code_label
));
2470 /* Fill in the gaps with the default. We may have gaps at
2471 the beginning if we tried to avoid the minval subtraction,
2472 so substitute some label even if the default label was
2473 deemed unreachable. */
2475 default_label
= fallback_label
;
2476 for (i
= 0; i
< ncases
; i
++)
2477 if (labelvec
[i
] == 0)
2478 labelvec
[i
] = gen_rtx_LABEL_REF (Pmode
, default_label
);
2480 /* Output the table. */
2481 emit_label (table_label
);
2483 if (CASE_VECTOR_PC_RELATIVE
|| flag_pic
)
2484 emit_jump_insn (gen_rtx_ADDR_DIFF_VEC (CASE_VECTOR_MODE
,
2485 gen_rtx_LABEL_REF (Pmode
, table_label
),
2486 gen_rtvec_v (ncases
, labelvec
),
2487 const0_rtx
, const0_rtx
));
2489 emit_jump_insn (gen_rtx_ADDR_VEC (CASE_VECTOR_MODE
,
2490 gen_rtvec_v (ncases
, labelvec
)));
2492 /* Record no drop-through after the table. */
2496 before_case
= NEXT_INSN (before_case
);
2497 end
= get_last_insn ();
2498 reorder_insns (before_case
, end
, start
);
2502 free_alloc_pool (case_node_pool
);
2505 /* Generate code to jump to LABEL if OP0 and OP1 are equal in mode MODE. */
2508 do_jump_if_equal (enum machine_mode mode
, rtx op0
, rtx op1
, rtx label
,
2511 do_compare_rtx_and_jump (op0
, op1
, EQ
, unsignedp
, mode
,
2512 NULL_RTX
, NULL_RTX
, label
);
2515 /* Not all case values are encountered equally. This function
2516 uses a heuristic to weight case labels, in cases where that
2517 looks like a reasonable thing to do.
2519 Right now, all we try to guess is text, and we establish the
2522 chars above space: 16
2531 If we find any cases in the switch that are not either -1 or in the range
2532 of valid ASCII characters, or are control characters other than those
2533 commonly used with "\", don't treat this switch scanning text.
2535 Return 1 if these nodes are suitable for cost estimation, otherwise
2539 estimate_case_costs (case_node_ptr node
)
2541 tree min_ascii
= integer_minus_one_node
;
2542 tree max_ascii
= build_int_cst (TREE_TYPE (node
->high
), 127);
2546 /* If we haven't already made the cost table, make it now. Note that the
2547 lower bound of the table is -1, not zero. */
2549 if (! cost_table_initialized
)
2551 cost_table_initialized
= 1;
2553 for (i
= 0; i
< 128; i
++)
2556 COST_TABLE (i
) = 16;
2557 else if (ISPUNCT (i
))
2559 else if (ISCNTRL (i
))
2560 COST_TABLE (i
) = -1;
2563 COST_TABLE (' ') = 8;
2564 COST_TABLE ('\t') = 4;
2565 COST_TABLE ('\0') = 4;
2566 COST_TABLE ('\n') = 2;
2567 COST_TABLE ('\f') = 1;
2568 COST_TABLE ('\v') = 1;
2569 COST_TABLE ('\b') = 1;
2572 /* See if all the case expressions look like text. It is text if the
2573 constant is >= -1 and the highest constant is <= 127. Do all comparisons
2574 as signed arithmetic since we don't want to ever access cost_table with a
2575 value less than -1. Also check that none of the constants in a range
2576 are strange control characters. */
2578 for (n
= node
; n
; n
= n
->right
)
2580 if (tree_int_cst_lt (n
->low
, min_ascii
)
2581 || tree_int_cst_lt (max_ascii
, n
->high
))
2584 for (i
= (HOST_WIDE_INT
) TREE_INT_CST_LOW (n
->low
);
2585 i
<= (HOST_WIDE_INT
) TREE_INT_CST_LOW (n
->high
); i
++)
2586 if (COST_TABLE (i
) < 0)
2590 /* All interesting values are within the range of interesting
2591 ASCII characters. */
2595 /* Take an ordered list of case nodes
2596 and transform them into a near optimal binary tree,
2597 on the assumption that any target code selection value is as
2598 likely as any other.
2600 The transformation is performed by splitting the ordered
2601 list into two equal sections plus a pivot. The parts are
2602 then attached to the pivot as left and right branches. Each
2603 branch is then transformed recursively. */
2606 balance_case_nodes (case_node_ptr
*head
, case_node_ptr parent
)
2619 /* Count the number of entries on branch. Also count the ranges. */
2623 if (!tree_int_cst_equal (np
->low
, np
->high
))
2627 cost
+= COST_TABLE (TREE_INT_CST_LOW (np
->high
));
2631 cost
+= COST_TABLE (TREE_INT_CST_LOW (np
->low
));
2639 /* Split this list if it is long enough for that to help. */
2644 /* Find the place in the list that bisects the list's total cost,
2645 Here I gets half the total cost. */
2650 /* Skip nodes while their cost does not reach that amount. */
2651 if (!tree_int_cst_equal ((*npp
)->low
, (*npp
)->high
))
2652 i
-= COST_TABLE (TREE_INT_CST_LOW ((*npp
)->high
));
2653 i
-= COST_TABLE (TREE_INT_CST_LOW ((*npp
)->low
));
2656 npp
= &(*npp
)->right
;
2661 /* Leave this branch lopsided, but optimize left-hand
2662 side and fill in `parent' fields for right-hand side. */
2664 np
->parent
= parent
;
2665 balance_case_nodes (&np
->left
, np
);
2666 for (; np
->right
; np
= np
->right
)
2667 np
->right
->parent
= np
;
2671 /* If there are just three nodes, split at the middle one. */
2673 npp
= &(*npp
)->right
;
2676 /* Find the place in the list that bisects the list's total cost,
2677 where ranges count as 2.
2678 Here I gets half the total cost. */
2679 i
= (i
+ ranges
+ 1) / 2;
2682 /* Skip nodes while their cost does not reach that amount. */
2683 if (!tree_int_cst_equal ((*npp
)->low
, (*npp
)->high
))
2688 npp
= &(*npp
)->right
;
2693 np
->parent
= parent
;
2696 /* Optimize each of the two split parts. */
2697 balance_case_nodes (&np
->left
, np
);
2698 balance_case_nodes (&np
->right
, np
);
2702 /* Else leave this branch as one level,
2703 but fill in `parent' fields. */
2705 np
->parent
= parent
;
2706 for (; np
->right
; np
= np
->right
)
2707 np
->right
->parent
= np
;
2712 /* Search the parent sections of the case node tree
2713 to see if a test for the lower bound of NODE would be redundant.
2714 INDEX_TYPE is the type of the index expression.
2716 The instructions to generate the case decision tree are
2717 output in the same order as nodes are processed so it is
2718 known that if a parent node checks the range of the current
2719 node minus one that the current node is bounded at its lower
2720 span. Thus the test would be redundant. */
2723 node_has_low_bound (case_node_ptr node
, tree index_type
)
2726 case_node_ptr pnode
;
2728 /* If the lower bound of this node is the lowest value in the index type,
2729 we need not test it. */
2731 if (tree_int_cst_equal (node
->low
, TYPE_MIN_VALUE (index_type
)))
2734 /* If this node has a left branch, the value at the left must be less
2735 than that at this node, so it cannot be bounded at the bottom and
2736 we need not bother testing any further. */
2741 low_minus_one
= fold_build2 (MINUS_EXPR
, TREE_TYPE (node
->low
),
2743 build_int_cst (TREE_TYPE (node
->low
), 1));
2745 /* If the subtraction above overflowed, we can't verify anything.
2746 Otherwise, look for a parent that tests our value - 1. */
2748 if (! tree_int_cst_lt (low_minus_one
, node
->low
))
2751 for (pnode
= node
->parent
; pnode
; pnode
= pnode
->parent
)
2752 if (tree_int_cst_equal (low_minus_one
, pnode
->high
))
2758 /* Search the parent sections of the case node tree
2759 to see if a test for the upper bound of NODE would be redundant.
2760 INDEX_TYPE is the type of the index expression.
2762 The instructions to generate the case decision tree are
2763 output in the same order as nodes are processed so it is
2764 known that if a parent node checks the range of the current
2765 node plus one that the current node is bounded at its upper
2766 span. Thus the test would be redundant. */
2769 node_has_high_bound (case_node_ptr node
, tree index_type
)
2772 case_node_ptr pnode
;
2774 /* If there is no upper bound, obviously no test is needed. */
2776 if (TYPE_MAX_VALUE (index_type
) == NULL
)
2779 /* If the upper bound of this node is the highest value in the type
2780 of the index expression, we need not test against it. */
2782 if (tree_int_cst_equal (node
->high
, TYPE_MAX_VALUE (index_type
)))
2785 /* If this node has a right branch, the value at the right must be greater
2786 than that at this node, so it cannot be bounded at the top and
2787 we need not bother testing any further. */
2792 high_plus_one
= fold_build2 (PLUS_EXPR
, TREE_TYPE (node
->high
),
2794 build_int_cst (TREE_TYPE (node
->high
), 1));
2796 /* If the addition above overflowed, we can't verify anything.
2797 Otherwise, look for a parent that tests our value + 1. */
2799 if (! tree_int_cst_lt (node
->high
, high_plus_one
))
2802 for (pnode
= node
->parent
; pnode
; pnode
= pnode
->parent
)
2803 if (tree_int_cst_equal (high_plus_one
, pnode
->low
))
2809 /* Search the parent sections of the
2810 case node tree to see if both tests for the upper and lower
2811 bounds of NODE would be redundant. */
2814 node_is_bounded (case_node_ptr node
, tree index_type
)
2816 return (node_has_low_bound (node
, index_type
)
2817 && node_has_high_bound (node
, index_type
));
2820 /* Emit step-by-step code to select a case for the value of INDEX.
2821 The thus generated decision tree follows the form of the
2822 case-node binary tree NODE, whose nodes represent test conditions.
2823 INDEX_TYPE is the type of the index of the switch.
2825 Care is taken to prune redundant tests from the decision tree
2826 by detecting any boundary conditions already checked by
2827 emitted rtx. (See node_has_high_bound, node_has_low_bound
2828 and node_is_bounded, above.)
2830 Where the test conditions can be shown to be redundant we emit
2831 an unconditional jump to the target code. As a further
2832 optimization, the subordinates of a tree node are examined to
2833 check for bounded nodes. In this case conditional and/or
2834 unconditional jumps as a result of the boundary check for the
2835 current node are arranged to target the subordinates associated
2836 code for out of bound conditions on the current node.
2838 We can assume that when control reaches the code generated here,
2839 the index value has already been compared with the parents
2840 of this node, and determined to be on the same side of each parent
2841 as this node is. Thus, if this node tests for the value 51,
2842 and a parent tested for 52, we don't need to consider
2843 the possibility of a value greater than 51. If another parent
2844 tests for the value 50, then this node need not test anything. */
2847 emit_case_nodes (rtx index
, case_node_ptr node
, rtx default_label
,
2850 /* If INDEX has an unsigned type, we must make unsigned branches. */
2851 int unsignedp
= TYPE_UNSIGNED (index_type
);
2852 enum machine_mode mode
= GET_MODE (index
);
2853 enum machine_mode imode
= TYPE_MODE (index_type
);
2855 /* Handle indices detected as constant during RTL expansion. */
2856 if (mode
== VOIDmode
)
2859 /* See if our parents have already tested everything for us.
2860 If they have, emit an unconditional jump for this node. */
2861 if (node_is_bounded (node
, index_type
))
2862 emit_jump (label_rtx (node
->code_label
));
2864 else if (tree_int_cst_equal (node
->low
, node
->high
))
2866 /* Node is single valued. First see if the index expression matches
2867 this node and then check our children, if any. */
2869 do_jump_if_equal (mode
, index
,
2870 convert_modes (mode
, imode
,
2871 expand_normal (node
->low
),
2873 label_rtx (node
->code_label
), unsignedp
);
2875 if (node
->right
!= 0 && node
->left
!= 0)
2877 /* This node has children on both sides.
2878 Dispatch to one side or the other
2879 by comparing the index value with this node's value.
2880 If one subtree is bounded, check that one first,
2881 so we can avoid real branches in the tree. */
2883 if (node_is_bounded (node
->right
, index_type
))
2885 emit_cmp_and_jump_insns (index
,
2888 expand_normal (node
->high
),
2890 GT
, NULL_RTX
, mode
, unsignedp
,
2891 label_rtx (node
->right
->code_label
));
2892 emit_case_nodes (index
, node
->left
, default_label
, index_type
);
2895 else if (node_is_bounded (node
->left
, index_type
))
2897 emit_cmp_and_jump_insns (index
,
2900 expand_normal (node
->high
),
2902 LT
, NULL_RTX
, mode
, unsignedp
,
2903 label_rtx (node
->left
->code_label
));
2904 emit_case_nodes (index
, node
->right
, default_label
, index_type
);
2907 /* If both children are single-valued cases with no
2908 children, finish up all the work. This way, we can save
2909 one ordered comparison. */
2910 else if (tree_int_cst_equal (node
->right
->low
, node
->right
->high
)
2911 && node
->right
->left
== 0
2912 && node
->right
->right
== 0
2913 && tree_int_cst_equal (node
->left
->low
, node
->left
->high
)
2914 && node
->left
->left
== 0
2915 && node
->left
->right
== 0)
2917 /* Neither node is bounded. First distinguish the two sides;
2918 then emit the code for one side at a time. */
2920 /* See if the value matches what the right hand side
2922 do_jump_if_equal (mode
, index
,
2923 convert_modes (mode
, imode
,
2924 expand_normal (node
->right
->low
),
2926 label_rtx (node
->right
->code_label
),
2929 /* See if the value matches what the left hand side
2931 do_jump_if_equal (mode
, index
,
2932 convert_modes (mode
, imode
,
2933 expand_normal (node
->left
->low
),
2935 label_rtx (node
->left
->code_label
),
2941 /* Neither node is bounded. First distinguish the two sides;
2942 then emit the code for one side at a time. */
2944 tree test_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
2946 /* See if the value is on the right. */
2947 emit_cmp_and_jump_insns (index
,
2950 expand_normal (node
->high
),
2952 GT
, NULL_RTX
, mode
, unsignedp
,
2953 label_rtx (test_label
));
2955 /* Value must be on the left.
2956 Handle the left-hand subtree. */
2957 emit_case_nodes (index
, node
->left
, default_label
, index_type
);
2958 /* If left-hand subtree does nothing,
2961 emit_jump (default_label
);
2963 /* Code branches here for the right-hand subtree. */
2964 expand_label (test_label
);
2965 emit_case_nodes (index
, node
->right
, default_label
, index_type
);
2969 else if (node
->right
!= 0 && node
->left
== 0)
2971 /* Here we have a right child but no left so we issue a conditional
2972 branch to default and process the right child.
2974 Omit the conditional branch to default if the right child
2975 does not have any children and is single valued; it would
2976 cost too much space to save so little time. */
2978 if (node
->right
->right
|| node
->right
->left
2979 || !tree_int_cst_equal (node
->right
->low
, node
->right
->high
))
2981 if (!node_has_low_bound (node
, index_type
))
2983 emit_cmp_and_jump_insns (index
,
2986 expand_normal (node
->high
),
2988 LT
, NULL_RTX
, mode
, unsignedp
,
2992 emit_case_nodes (index
, node
->right
, default_label
, index_type
);
2995 /* We cannot process node->right normally
2996 since we haven't ruled out the numbers less than
2997 this node's value. So handle node->right explicitly. */
2998 do_jump_if_equal (mode
, index
,
3001 expand_normal (node
->right
->low
),
3003 label_rtx (node
->right
->code_label
), unsignedp
);
3006 else if (node
->right
== 0 && node
->left
!= 0)
3008 /* Just one subtree, on the left. */
3009 if (node
->left
->left
|| node
->left
->right
3010 || !tree_int_cst_equal (node
->left
->low
, node
->left
->high
))
3012 if (!node_has_high_bound (node
, index_type
))
3014 emit_cmp_and_jump_insns (index
,
3017 expand_normal (node
->high
),
3019 GT
, NULL_RTX
, mode
, unsignedp
,
3023 emit_case_nodes (index
, node
->left
, default_label
, index_type
);
3026 /* We cannot process node->left normally
3027 since we haven't ruled out the numbers less than
3028 this node's value. So handle node->left explicitly. */
3029 do_jump_if_equal (mode
, index
,
3032 expand_normal (node
->left
->low
),
3034 label_rtx (node
->left
->code_label
), unsignedp
);
3039 /* Node is a range. These cases are very similar to those for a single
3040 value, except that we do not start by testing whether this node
3041 is the one to branch to. */
3043 if (node
->right
!= 0 && node
->left
!= 0)
3045 /* Node has subtrees on both sides.
3046 If the right-hand subtree is bounded,
3047 test for it first, since we can go straight there.
3048 Otherwise, we need to make a branch in the control structure,
3049 then handle the two subtrees. */
3050 tree test_label
= 0;
3052 if (node_is_bounded (node
->right
, index_type
))
3053 /* Right hand node is fully bounded so we can eliminate any
3054 testing and branch directly to the target code. */
3055 emit_cmp_and_jump_insns (index
,
3058 expand_normal (node
->high
),
3060 GT
, NULL_RTX
, mode
, unsignedp
,
3061 label_rtx (node
->right
->code_label
));
3064 /* Right hand node requires testing.
3065 Branch to a label where we will handle it later. */
3067 test_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3068 emit_cmp_and_jump_insns (index
,
3071 expand_normal (node
->high
),
3073 GT
, NULL_RTX
, mode
, unsignedp
,
3074 label_rtx (test_label
));
3077 /* Value belongs to this node or to the left-hand subtree. */
3079 emit_cmp_and_jump_insns (index
,
3082 expand_normal (node
->low
),
3084 GE
, NULL_RTX
, mode
, unsignedp
,
3085 label_rtx (node
->code_label
));
3087 /* Handle the left-hand subtree. */
3088 emit_case_nodes (index
, node
->left
, default_label
, index_type
);
3090 /* If right node had to be handled later, do that now. */
3094 /* If the left-hand subtree fell through,
3095 don't let it fall into the right-hand subtree. */
3097 emit_jump (default_label
);
3099 expand_label (test_label
);
3100 emit_case_nodes (index
, node
->right
, default_label
, index_type
);
3104 else if (node
->right
!= 0 && node
->left
== 0)
3106 /* Deal with values to the left of this node,
3107 if they are possible. */
3108 if (!node_has_low_bound (node
, index_type
))
3110 emit_cmp_and_jump_insns (index
,
3113 expand_normal (node
->low
),
3115 LT
, NULL_RTX
, mode
, unsignedp
,
3119 /* Value belongs to this node or to the right-hand subtree. */
3121 emit_cmp_and_jump_insns (index
,
3124 expand_normal (node
->high
),
3126 LE
, NULL_RTX
, mode
, unsignedp
,
3127 label_rtx (node
->code_label
));
3129 emit_case_nodes (index
, node
->right
, default_label
, index_type
);
3132 else if (node
->right
== 0 && node
->left
!= 0)
3134 /* Deal with values to the right of this node,
3135 if they are possible. */
3136 if (!node_has_high_bound (node
, index_type
))
3138 emit_cmp_and_jump_insns (index
,
3141 expand_normal (node
->high
),
3143 GT
, NULL_RTX
, mode
, unsignedp
,
3147 /* Value belongs to this node or to the left-hand subtree. */
3149 emit_cmp_and_jump_insns (index
,
3152 expand_normal (node
->low
),
3154 GE
, NULL_RTX
, mode
, unsignedp
,
3155 label_rtx (node
->code_label
));
3157 emit_case_nodes (index
, node
->left
, default_label
, index_type
);
3162 /* Node has no children so we check low and high bounds to remove
3163 redundant tests. Only one of the bounds can exist,
3164 since otherwise this node is bounded--a case tested already. */
3165 int high_bound
= node_has_high_bound (node
, index_type
);
3166 int low_bound
= node_has_low_bound (node
, index_type
);
3168 if (!high_bound
&& low_bound
)
3170 emit_cmp_and_jump_insns (index
,
3173 expand_normal (node
->high
),
3175 GT
, NULL_RTX
, mode
, unsignedp
,
3179 else if (!low_bound
&& high_bound
)
3181 emit_cmp_and_jump_insns (index
,
3184 expand_normal (node
->low
),
3186 LT
, NULL_RTX
, mode
, unsignedp
,
3189 else if (!low_bound
&& !high_bound
)
3191 /* Widen LOW and HIGH to the same width as INDEX. */
3192 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
3193 tree low
= build1 (CONVERT_EXPR
, type
, node
->low
);
3194 tree high
= build1 (CONVERT_EXPR
, type
, node
->high
);
3195 rtx low_rtx
, new_index
, new_bound
;
3197 /* Instead of doing two branches, emit one unsigned branch for
3198 (index-low) > (high-low). */
3199 low_rtx
= expand_expr (low
, NULL_RTX
, mode
, EXPAND_NORMAL
);
3200 new_index
= expand_simple_binop (mode
, MINUS
, index
, low_rtx
,
3201 NULL_RTX
, unsignedp
,
3203 new_bound
= expand_expr (fold_build2 (MINUS_EXPR
, type
,
3205 NULL_RTX
, mode
, EXPAND_NORMAL
);
3207 emit_cmp_and_jump_insns (new_index
, new_bound
, GT
, NULL_RTX
,
3208 mode
, 1, default_label
);
3211 emit_jump (label_rtx (node
->code_label
));