OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [calls.c] - Blame information for rev 328

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* Convert function calls to rtl insns, for GNU C compiler.
2
   Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3
   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4
   Free Software Foundation, Inc.
5
 
6
This file is part of GCC.
7
 
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
11
version.
12
 
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
16
for more details.
17
 
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/>.  */
21
 
22
#include "config.h"
23
#include "system.h"
24
#include "coretypes.h"
25
#include "tm.h"
26
#include "rtl.h"
27
#include "tree.h"
28
#include "gimple.h"
29
#include "flags.h"
30
#include "expr.h"
31
#include "optabs.h"
32
#include "libfuncs.h"
33
#include "function.h"
34
#include "regs.h"
35
#include "toplev.h"
36
#include "output.h"
37
#include "tm_p.h"
38
#include "timevar.h"
39
#include "sbitmap.h"
40
#include "langhooks.h"
41
#include "target.h"
42
#include "debug.h"
43
#include "cgraph.h"
44
#include "except.h"
45
#include "dbgcnt.h"
46
#include "tree-flow.h"
47
 
48
/* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits.  */
49
#define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
50
 
51
/* Data structure and subroutines used within expand_call.  */
52
 
53
struct arg_data
54
{
55
  /* Tree node for this argument.  */
56
  tree tree_value;
57
  /* Mode for value; TYPE_MODE unless promoted.  */
58
  enum machine_mode mode;
59
  /* Current RTL value for argument, or 0 if it isn't precomputed.  */
60
  rtx value;
61
  /* Initially-compute RTL value for argument; only for const functions.  */
62
  rtx initial_value;
63
  /* Register to pass this argument in, 0 if passed on stack, or an
64
     PARALLEL if the arg is to be copied into multiple non-contiguous
65
     registers.  */
66
  rtx reg;
67
  /* Register to pass this argument in when generating tail call sequence.
68
     This is not the same register as for normal calls on machines with
69
     register windows.  */
70
  rtx tail_call_reg;
71
  /* If REG is a PARALLEL, this is a copy of VALUE pulled into the correct
72
     form for emit_group_move.  */
73
  rtx parallel_value;
74
  /* If REG was promoted from the actual mode of the argument expression,
75
     indicates whether the promotion is sign- or zero-extended.  */
76
  int unsignedp;
77
  /* Number of bytes to put in registers.  0 means put the whole arg
78
     in registers.  Also 0 if not passed in registers.  */
79
  int partial;
80
  /* Nonzero if argument must be passed on stack.
81
     Note that some arguments may be passed on the stack
82
     even though pass_on_stack is zero, just because FUNCTION_ARG says so.
83
     pass_on_stack identifies arguments that *cannot* go in registers.  */
84
  int pass_on_stack;
85
  /* Some fields packaged up for locate_and_pad_parm.  */
86
  struct locate_and_pad_arg_data locate;
87
  /* Location on the stack at which parameter should be stored.  The store
88
     has already been done if STACK == VALUE.  */
89
  rtx stack;
90
  /* Location on the stack of the start of this argument slot.  This can
91
     differ from STACK if this arg pads downward.  This location is known
92
     to be aligned to FUNCTION_ARG_BOUNDARY.  */
93
  rtx stack_slot;
94
  /* Place that this stack area has been saved, if needed.  */
95
  rtx save_area;
96
  /* If an argument's alignment does not permit direct copying into registers,
97
     copy in smaller-sized pieces into pseudos.  These are stored in a
98
     block pointed to by this field.  The next field says how many
99
     word-sized pseudos we made.  */
100
  rtx *aligned_regs;
101
  int n_aligned_regs;
102
};
103
 
104
/* A vector of one char per byte of stack space.  A byte if nonzero if
105
   the corresponding stack location has been used.
106
   This vector is used to prevent a function call within an argument from
107
   clobbering any stack already set up.  */
108
static char *stack_usage_map;
109
 
110
/* Size of STACK_USAGE_MAP.  */
111
static int highest_outgoing_arg_in_use;
112
 
113
/* A bitmap of virtual-incoming stack space.  Bit is set if the corresponding
114
   stack location's tail call argument has been already stored into the stack.
115
   This bitmap is used to prevent sibling call optimization if function tries
116
   to use parent's incoming argument slots when they have been already
117
   overwritten with tail call arguments.  */
118
static sbitmap stored_args_map;
119
 
120
/* stack_arg_under_construction is nonzero when an argument may be
121
   initialized with a constructor call (including a C function that
122
   returns a BLKmode struct) and expand_call must take special action
123
   to make sure the object being constructed does not overlap the
124
   argument list for the constructor call.  */
125
static int stack_arg_under_construction;
126
 
127
static void emit_call_1 (rtx, tree, tree, tree, HOST_WIDE_INT, HOST_WIDE_INT,
128
                         HOST_WIDE_INT, rtx, rtx, int, rtx, int,
129
                         CUMULATIVE_ARGS *);
130
static void precompute_register_parameters (int, struct arg_data *, int *);
131
static int store_one_arg (struct arg_data *, rtx, int, int, int);
132
static void store_unaligned_arguments_into_pseudos (struct arg_data *, int);
133
static int finalize_must_preallocate (int, int, struct arg_data *,
134
                                      struct args_size *);
135
static void precompute_arguments (int, struct arg_data *);
136
static int compute_argument_block_size (int, struct args_size *, tree, tree, int);
137
static void initialize_argument_information (int, struct arg_data *,
138
                                             struct args_size *, int,
139
                                             tree, tree,
140
                                             tree, tree, CUMULATIVE_ARGS *, int,
141
                                             rtx *, int *, int *, int *,
142
                                             bool *, bool);
143
static void compute_argument_addresses (struct arg_data *, rtx, int);
144
static rtx rtx_for_function_call (tree, tree);
145
static void load_register_parameters (struct arg_data *, int, rtx *, int,
146
                                      int, int *);
147
static rtx emit_library_call_value_1 (int, rtx, rtx, enum libcall_type,
148
                                      enum machine_mode, int, va_list);
149
static int special_function_p (const_tree, int);
150
static int check_sibcall_argument_overlap_1 (rtx);
151
static int check_sibcall_argument_overlap (rtx, struct arg_data *, int);
152
 
153
static int combine_pending_stack_adjustment_and_call (int, struct args_size *,
154
                                                      unsigned int);
155
static tree split_complex_types (tree);
156
 
157
#ifdef REG_PARM_STACK_SPACE
158
static rtx save_fixed_argument_area (int, rtx, int *, int *);
159
static void restore_fixed_argument_area (rtx, rtx, int, int);
160
#endif
161
 
162
/* Force FUNEXP into a form suitable for the address of a CALL,
163
   and return that as an rtx.  Also load the static chain register
164
   if FNDECL is a nested function.
165
 
166
   CALL_FUSAGE points to a variable holding the prospective
167
   CALL_INSN_FUNCTION_USAGE information.  */
168
 
169
rtx
170
prepare_call_address (tree fndecl, rtx funexp, rtx static_chain_value,
171
                      rtx *call_fusage, int reg_parm_seen, int sibcallp)
172
{
173
  /* Make a valid memory address and copy constants through pseudo-regs,
174
     but not for a constant address if -fno-function-cse.  */
175
  if (GET_CODE (funexp) != SYMBOL_REF)
176
    /* If we are using registers for parameters, force the
177
       function address into a register now.  */
178
    funexp = ((SMALL_REGISTER_CLASSES && reg_parm_seen)
179
              ? force_not_mem (memory_address (FUNCTION_MODE, funexp))
180
              : memory_address (FUNCTION_MODE, funexp));
181
  else if (! sibcallp)
182
    {
183
#ifndef NO_FUNCTION_CSE
184
      if (optimize && ! flag_no_function_cse)
185
        funexp = force_reg (Pmode, funexp);
186
#endif
187
    }
188
 
189
  if (static_chain_value != 0)
190
    {
191
      rtx chain;
192
 
193
      gcc_assert (fndecl);
194
      chain = targetm.calls.static_chain (fndecl, false);
195
      static_chain_value = convert_memory_address (Pmode, static_chain_value);
196
 
197
      emit_move_insn (chain, static_chain_value);
198
      if (REG_P (chain))
199
        use_reg (call_fusage, chain);
200
    }
201
 
202
  return funexp;
203
}
204
 
205
/* Generate instructions to call function FUNEXP,
206
   and optionally pop the results.
207
   The CALL_INSN is the first insn generated.
208
 
209
   FNDECL is the declaration node of the function.  This is given to the
210
   macro RETURN_POPS_ARGS to determine whether this function pops its own args.
211
 
212
   FUNTYPE is the data type of the function.  This is given to the macro
213
   RETURN_POPS_ARGS to determine whether this function pops its own args.
214
   We used to allow an identifier for library functions, but that doesn't
215
   work when the return type is an aggregate type and the calling convention
216
   says that the pointer to this aggregate is to be popped by the callee.
217
 
218
   STACK_SIZE is the number of bytes of arguments on the stack,
219
   ROUNDED_STACK_SIZE is that number rounded up to
220
   PREFERRED_STACK_BOUNDARY; zero if the size is variable.  This is
221
   both to put into the call insn and to generate explicit popping
222
   code if necessary.
223
 
224
   STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
225
   It is zero if this call doesn't want a structure value.
226
 
227
   NEXT_ARG_REG is the rtx that results from executing
228
     FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1)
229
   just after all the args have had their registers assigned.
230
   This could be whatever you like, but normally it is the first
231
   arg-register beyond those used for args in this call,
232
   or 0 if all the arg-registers are used in this call.
233
   It is passed on to `gen_call' so you can put this info in the call insn.
234
 
235
   VALREG is a hard register in which a value is returned,
236
   or 0 if the call does not return a value.
237
 
238
   OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
239
   the args to this call were processed.
240
   We restore `inhibit_defer_pop' to that value.
241
 
242
   CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
243
   denote registers used by the called function.  */
244
 
245
static void
246
emit_call_1 (rtx funexp, tree fntree ATTRIBUTE_UNUSED, tree fndecl ATTRIBUTE_UNUSED,
247
             tree funtype ATTRIBUTE_UNUSED,
248
             HOST_WIDE_INT stack_size ATTRIBUTE_UNUSED,
249
             HOST_WIDE_INT rounded_stack_size,
250
             HOST_WIDE_INT struct_value_size ATTRIBUTE_UNUSED,
251
             rtx next_arg_reg ATTRIBUTE_UNUSED, rtx valreg,
252
             int old_inhibit_defer_pop, rtx call_fusage, int ecf_flags,
253
             CUMULATIVE_ARGS *args_so_far ATTRIBUTE_UNUSED)
254
{
255
  rtx rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
256
  rtx call_insn;
257
  int already_popped = 0;
258
  HOST_WIDE_INT n_popped = RETURN_POPS_ARGS (fndecl, funtype, stack_size);
259
 
260
#ifdef CALL_POPS_ARGS
261
  n_popped += CALL_POPS_ARGS (* args_so_far);
262
#endif
263
 
264
  /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
265
     and we don't want to load it into a register as an optimization,
266
     because prepare_call_address already did it if it should be done.  */
267
  if (GET_CODE (funexp) != SYMBOL_REF)
268
    funexp = memory_address (FUNCTION_MODE, funexp);
269
 
270
#if defined (HAVE_sibcall_pop) && defined (HAVE_sibcall_value_pop)
271
  if ((ecf_flags & ECF_SIBCALL)
272
      && HAVE_sibcall_pop && HAVE_sibcall_value_pop
273
      && (n_popped > 0 || stack_size == 0))
274
    {
275
      rtx n_pop = GEN_INT (n_popped);
276
      rtx pat;
277
 
278
      /* If this subroutine pops its own args, record that in the call insn
279
         if possible, for the sake of frame pointer elimination.  */
280
 
281
      if (valreg)
282
        pat = GEN_SIBCALL_VALUE_POP (valreg,
283
                                     gen_rtx_MEM (FUNCTION_MODE, funexp),
284
                                     rounded_stack_size_rtx, next_arg_reg,
285
                                     n_pop);
286
      else
287
        pat = GEN_SIBCALL_POP (gen_rtx_MEM (FUNCTION_MODE, funexp),
288
                               rounded_stack_size_rtx, next_arg_reg, n_pop);
289
 
290
      emit_call_insn (pat);
291
      already_popped = 1;
292
    }
293
  else
294
#endif
295
 
296
#if defined (HAVE_call_pop) && defined (HAVE_call_value_pop)
297
  /* If the target has "call" or "call_value" insns, then prefer them
298
     if no arguments are actually popped.  If the target does not have
299
     "call" or "call_value" insns, then we must use the popping versions
300
     even if the call has no arguments to pop.  */
301
#if defined (HAVE_call) && defined (HAVE_call_value)
302
  if (HAVE_call && HAVE_call_value && HAVE_call_pop && HAVE_call_value_pop
303
      && n_popped > 0)
304
#else
305
  if (HAVE_call_pop && HAVE_call_value_pop)
306
#endif
307
    {
308
      rtx n_pop = GEN_INT (n_popped);
309
      rtx pat;
310
 
311
      /* If this subroutine pops its own args, record that in the call insn
312
         if possible, for the sake of frame pointer elimination.  */
313
 
314
      if (valreg)
315
        pat = GEN_CALL_VALUE_POP (valreg,
316
                                  gen_rtx_MEM (FUNCTION_MODE, funexp),
317
                                  rounded_stack_size_rtx, next_arg_reg, n_pop);
318
      else
319
        pat = GEN_CALL_POP (gen_rtx_MEM (FUNCTION_MODE, funexp),
320
                            rounded_stack_size_rtx, next_arg_reg, n_pop);
321
 
322
      emit_call_insn (pat);
323
      already_popped = 1;
324
    }
325
  else
326
#endif
327
 
328
#if defined (HAVE_sibcall) && defined (HAVE_sibcall_value)
329
  if ((ecf_flags & ECF_SIBCALL)
330
      && HAVE_sibcall && HAVE_sibcall_value)
331
    {
332
      if (valreg)
333
        emit_call_insn (GEN_SIBCALL_VALUE (valreg,
334
                                           gen_rtx_MEM (FUNCTION_MODE, funexp),
335
                                           rounded_stack_size_rtx,
336
                                           next_arg_reg, NULL_RTX));
337
      else
338
        emit_call_insn (GEN_SIBCALL (gen_rtx_MEM (FUNCTION_MODE, funexp),
339
                                     rounded_stack_size_rtx, next_arg_reg,
340
                                     GEN_INT (struct_value_size)));
341
    }
342
  else
343
#endif
344
 
345
#if defined (HAVE_call) && defined (HAVE_call_value)
346
  if (HAVE_call && HAVE_call_value)
347
    {
348
      if (valreg)
349
        emit_call_insn (GEN_CALL_VALUE (valreg,
350
                                        gen_rtx_MEM (FUNCTION_MODE, funexp),
351
                                        rounded_stack_size_rtx, next_arg_reg,
352
                                        NULL_RTX));
353
      else
354
        emit_call_insn (GEN_CALL (gen_rtx_MEM (FUNCTION_MODE, funexp),
355
                                  rounded_stack_size_rtx, next_arg_reg,
356
                                  GEN_INT (struct_value_size)));
357
    }
358
  else
359
#endif
360
    gcc_unreachable ();
361
 
362
  /* Find the call we just emitted.  */
363
  call_insn = last_call_insn ();
364
 
365
  /* Put the register usage information there.  */
366
  add_function_usage_to (call_insn, call_fusage);
367
 
368
  /* If this is a const call, then set the insn's unchanging bit.  */
369
  if (ecf_flags & ECF_CONST)
370
    RTL_CONST_CALL_P (call_insn) = 1;
371
 
372
  /* If this is a pure call, then set the insn's unchanging bit.  */
373
  if (ecf_flags & ECF_PURE)
374
    RTL_PURE_CALL_P (call_insn) = 1;
375
 
376
  /* If this is a const call, then set the insn's unchanging bit.  */
377
  if (ecf_flags & ECF_LOOPING_CONST_OR_PURE)
378
    RTL_LOOPING_CONST_OR_PURE_CALL_P (call_insn) = 1;
379
 
380
  /* Create a nothrow REG_EH_REGION note, if needed.  */
381
  make_reg_eh_region_note (call_insn, ecf_flags, 0);
382
 
383
  if (ecf_flags & ECF_NORETURN)
384
    add_reg_note (call_insn, REG_NORETURN, const0_rtx);
385
 
386
  if (ecf_flags & ECF_RETURNS_TWICE)
387
    {
388
      add_reg_note (call_insn, REG_SETJMP, const0_rtx);
389
      cfun->calls_setjmp = 1;
390
    }
391
 
392
  SIBLING_CALL_P (call_insn) = ((ecf_flags & ECF_SIBCALL) != 0);
393
 
394
  /* Record debug information for virtual calls.  */
395
  if (flag_enable_icf_debug && fndecl == NULL)
396
    (*debug_hooks->virtual_call_token) (CALL_EXPR_FN (fntree),
397
                                        INSN_UID (call_insn));
398
 
399
  /* Restore this now, so that we do defer pops for this call's args
400
     if the context of the call as a whole permits.  */
401
  inhibit_defer_pop = old_inhibit_defer_pop;
402
 
403
  if (n_popped > 0)
404
    {
405
      if (!already_popped)
406
        CALL_INSN_FUNCTION_USAGE (call_insn)
407
          = gen_rtx_EXPR_LIST (VOIDmode,
408
                               gen_rtx_CLOBBER (VOIDmode, stack_pointer_rtx),
409
                               CALL_INSN_FUNCTION_USAGE (call_insn));
410
      rounded_stack_size -= n_popped;
411
      rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
412
      stack_pointer_delta -= n_popped;
413
 
414
      /* If popup is needed, stack realign must use DRAP  */
415
      if (SUPPORTS_STACK_ALIGNMENT)
416
        crtl->need_drap = true;
417
    }
418
 
419
  if (!ACCUMULATE_OUTGOING_ARGS)
420
    {
421
      /* If returning from the subroutine does not automatically pop the args,
422
         we need an instruction to pop them sooner or later.
423
         Perhaps do it now; perhaps just record how much space to pop later.
424
 
425
         If returning from the subroutine does pop the args, indicate that the
426
         stack pointer will be changed.  */
427
 
428
      if (rounded_stack_size != 0)
429
        {
430
          if (ecf_flags & ECF_NORETURN)
431
            /* Just pretend we did the pop.  */
432
            stack_pointer_delta -= rounded_stack_size;
433
          else if (flag_defer_pop && inhibit_defer_pop == 0
434
              && ! (ecf_flags & (ECF_CONST | ECF_PURE)))
435
            pending_stack_adjust += rounded_stack_size;
436
          else
437
            adjust_stack (rounded_stack_size_rtx);
438
        }
439
    }
440
  /* When we accumulate outgoing args, we must avoid any stack manipulations.
441
     Restore the stack pointer to its original value now.  Usually
442
     ACCUMULATE_OUTGOING_ARGS targets don't get here, but there are exceptions.
443
     On  i386 ACCUMULATE_OUTGOING_ARGS can be enabled on demand, and
444
     popping variants of functions exist as well.
445
 
446
     ??? We may optimize similar to defer_pop above, but it is
447
     probably not worthwhile.
448
 
449
     ??? It will be worthwhile to enable combine_stack_adjustments even for
450
     such machines.  */
451
  else if (n_popped)
452
    anti_adjust_stack (GEN_INT (n_popped));
453
}
454
 
455
/* Determine if the function identified by NAME and FNDECL is one with
456
   special properties we wish to know about.
457
 
458
   For example, if the function might return more than one time (setjmp), then
459
   set RETURNS_TWICE to a nonzero value.
460
 
461
   Similarly set NORETURN if the function is in the longjmp family.
462
 
463
   Set MAY_BE_ALLOCA for any memory allocation function that might allocate
464
   space from the stack such as alloca.  */
465
 
466
static int
467
special_function_p (const_tree fndecl, int flags)
468
{
469
  if (fndecl && DECL_NAME (fndecl)
470
      && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) <= 17
471
      /* Exclude functions not at the file scope, or not `extern',
472
         since they are not the magic functions we would otherwise
473
         think they are.
474
         FIXME: this should be handled with attributes, not with this
475
         hacky imitation of DECL_ASSEMBLER_NAME.  It's (also) wrong
476
         because you can declare fork() inside a function if you
477
         wish.  */
478
      && (DECL_CONTEXT (fndecl) == NULL_TREE
479
          || TREE_CODE (DECL_CONTEXT (fndecl)) == TRANSLATION_UNIT_DECL)
480
      && TREE_PUBLIC (fndecl))
481
    {
482
      const char *name = IDENTIFIER_POINTER (DECL_NAME (fndecl));
483
      const char *tname = name;
484
 
485
      /* We assume that alloca will always be called by name.  It
486
         makes no sense to pass it as a pointer-to-function to
487
         anything that does not understand its behavior.  */
488
      if (((IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 6
489
            && name[0] == 'a'
490
            && ! strcmp (name, "alloca"))
491
           || (IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 16
492
               && name[0] == '_'
493
               && ! strcmp (name, "__builtin_alloca"))))
494
        flags |= ECF_MAY_BE_ALLOCA;
495
 
496
      /* Disregard prefix _, __, __x or __builtin_.  */
497
      if (name[0] == '_')
498
        {
499
          if (name[1] == '_'
500
              && name[2] == 'b'
501
              && !strncmp (name + 3, "uiltin_", 7))
502
            tname += 10;
503
          else if (name[1] == '_' && name[2] == 'x')
504
            tname += 3;
505
          else if (name[1] == '_')
506
            tname += 2;
507
          else
508
            tname += 1;
509
        }
510
 
511
      if (tname[0] == 's')
512
        {
513
          if ((tname[1] == 'e'
514
               && (! strcmp (tname, "setjmp")
515
                   || ! strcmp (tname, "setjmp_syscall")))
516
              || (tname[1] == 'i'
517
                  && ! strcmp (tname, "sigsetjmp"))
518
              || (tname[1] == 'a'
519
                  && ! strcmp (tname, "savectx")))
520
            flags |= ECF_RETURNS_TWICE;
521
 
522
          if (tname[1] == 'i'
523
              && ! strcmp (tname, "siglongjmp"))
524
            flags |= ECF_NORETURN;
525
        }
526
      else if ((tname[0] == 'q' && tname[1] == 's'
527
                && ! strcmp (tname, "qsetjmp"))
528
               || (tname[0] == 'v' && tname[1] == 'f'
529
                   && ! strcmp (tname, "vfork"))
530
               || (tname[0] == 'g' && tname[1] == 'e'
531
                   && !strcmp (tname, "getcontext")))
532
        flags |= ECF_RETURNS_TWICE;
533
 
534
      else if (tname[0] == 'l' && tname[1] == 'o'
535
               && ! strcmp (tname, "longjmp"))
536
        flags |= ECF_NORETURN;
537
    }
538
 
539
  return flags;
540
}
541
 
542
/* Return nonzero when FNDECL represents a call to setjmp.  */
543
 
544
int
545
setjmp_call_p (const_tree fndecl)
546
{
547
  return special_function_p (fndecl, 0) & ECF_RETURNS_TWICE;
548
}
549
 
550
 
551
/* Return true if STMT is an alloca call.  */
552
 
553
bool
554
gimple_alloca_call_p (const_gimple stmt)
555
{
556
  tree fndecl;
557
 
558
  if (!is_gimple_call (stmt))
559
    return false;
560
 
561
  fndecl = gimple_call_fndecl (stmt);
562
  if (fndecl && (special_function_p (fndecl, 0) & ECF_MAY_BE_ALLOCA))
563
    return true;
564
 
565
  return false;
566
}
567
 
568
/* Return true when exp contains alloca call.  */
569
 
570
bool
571
alloca_call_p (const_tree exp)
572
{
573
  if (TREE_CODE (exp) == CALL_EXPR
574
      && TREE_CODE (CALL_EXPR_FN (exp)) == ADDR_EXPR
575
      && (TREE_CODE (TREE_OPERAND (CALL_EXPR_FN (exp), 0)) == FUNCTION_DECL)
576
      && (special_function_p (TREE_OPERAND (CALL_EXPR_FN (exp), 0), 0)
577
          & ECF_MAY_BE_ALLOCA))
578
    return true;
579
  return false;
580
}
581
 
582
/* Detect flags (function attributes) from the function decl or type node.  */
583
 
584
int
585
flags_from_decl_or_type (const_tree exp)
586
{
587
  int flags = 0;
588
 
589
  if (DECL_P (exp))
590
    {
591
      /* The function exp may have the `malloc' attribute.  */
592
      if (DECL_IS_MALLOC (exp))
593
        flags |= ECF_MALLOC;
594
 
595
      /* The function exp may have the `returns_twice' attribute.  */
596
      if (DECL_IS_RETURNS_TWICE (exp))
597
        flags |= ECF_RETURNS_TWICE;
598
 
599
      /* Process the pure and const attributes.  */
600
      if (TREE_READONLY (exp) && ! TREE_THIS_VOLATILE (exp))
601
        flags |= ECF_CONST;
602
      if (DECL_PURE_P (exp))
603
        flags |= ECF_PURE;
604
      if (DECL_LOOPING_CONST_OR_PURE_P (exp))
605
        flags |= ECF_LOOPING_CONST_OR_PURE;
606
 
607
      if (DECL_IS_NOVOPS (exp))
608
        flags |= ECF_NOVOPS;
609
 
610
      if (TREE_NOTHROW (exp))
611
        flags |= ECF_NOTHROW;
612
 
613
      flags = special_function_p (exp, flags);
614
    }
615
  else if (TYPE_P (exp) && TYPE_READONLY (exp) && ! TREE_THIS_VOLATILE (exp))
616
    flags |= ECF_CONST;
617
 
618
  if (TREE_THIS_VOLATILE (exp))
619
    flags |= ECF_NORETURN;
620
 
621
  return flags;
622
}
623
 
624
/* Detect flags from a CALL_EXPR.  */
625
 
626
int
627
call_expr_flags (const_tree t)
628
{
629
  int flags;
630
  tree decl = get_callee_fndecl (t);
631
 
632
  if (decl)
633
    flags = flags_from_decl_or_type (decl);
634
  else
635
    {
636
      t = TREE_TYPE (CALL_EXPR_FN (t));
637
      if (t && TREE_CODE (t) == POINTER_TYPE)
638
        flags = flags_from_decl_or_type (TREE_TYPE (t));
639
      else
640
        flags = 0;
641
    }
642
 
643
  return flags;
644
}
645
 
646
/* Precompute all register parameters as described by ARGS, storing values
647
   into fields within the ARGS array.
648
 
649
   NUM_ACTUALS indicates the total number elements in the ARGS array.
650
 
651
   Set REG_PARM_SEEN if we encounter a register parameter.  */
652
 
653
static void
654
precompute_register_parameters (int num_actuals, struct arg_data *args,
655
                                int *reg_parm_seen)
656
{
657
  int i;
658
 
659
  *reg_parm_seen = 0;
660
 
661
  for (i = 0; i < num_actuals; i++)
662
    if (args[i].reg != 0 && ! args[i].pass_on_stack)
663
      {
664
        *reg_parm_seen = 1;
665
 
666
        if (args[i].value == 0)
667
          {
668
            push_temp_slots ();
669
            args[i].value = expand_normal (args[i].tree_value);
670
            preserve_temp_slots (args[i].value);
671
            pop_temp_slots ();
672
          }
673
 
674
        /* If the value is a non-legitimate constant, force it into a
675
           pseudo now.  TLS symbols sometimes need a call to resolve.  */
676
        if (CONSTANT_P (args[i].value)
677
            && !LEGITIMATE_CONSTANT_P (args[i].value))
678
          args[i].value = force_reg (args[i].mode, args[i].value);
679
 
680
        /* If we are to promote the function arg to a wider mode,
681
           do it now.  */
682
 
683
        if (args[i].mode != TYPE_MODE (TREE_TYPE (args[i].tree_value)))
684
          args[i].value
685
            = convert_modes (args[i].mode,
686
                             TYPE_MODE (TREE_TYPE (args[i].tree_value)),
687
                             args[i].value, args[i].unsignedp);
688
 
689
        /* If we're going to have to load the value by parts, pull the
690
           parts into pseudos.  The part extraction process can involve
691
           non-trivial computation.  */
692
        if (GET_CODE (args[i].reg) == PARALLEL)
693
          {
694
            tree type = TREE_TYPE (args[i].tree_value);
695
            args[i].parallel_value
696
              = emit_group_load_into_temps (args[i].reg, args[i].value,
697
                                            type, int_size_in_bytes (type));
698
          }
699
 
700
        /* If the value is expensive, and we are inside an appropriately
701
           short loop, put the value into a pseudo and then put the pseudo
702
           into the hard reg.
703
 
704
           For small register classes, also do this if this call uses
705
           register parameters.  This is to avoid reload conflicts while
706
           loading the parameters registers.  */
707
 
708
        else if ((! (REG_P (args[i].value)
709
                     || (GET_CODE (args[i].value) == SUBREG
710
                         && REG_P (SUBREG_REG (args[i].value)))))
711
                 && args[i].mode != BLKmode
712
                 && rtx_cost (args[i].value, SET, optimize_insn_for_speed_p ())
713
                    > COSTS_N_INSNS (1)
714
                 && ((SMALL_REGISTER_CLASSES && *reg_parm_seen)
715
                     || optimize))
716
          args[i].value = copy_to_mode_reg (args[i].mode, args[i].value);
717
      }
718
}
719
 
720
#ifdef REG_PARM_STACK_SPACE
721
 
722
  /* The argument list is the property of the called routine and it
723
     may clobber it.  If the fixed area has been used for previous
724
     parameters, we must save and restore it.  */
725
 
726
static rtx
727
save_fixed_argument_area (int reg_parm_stack_space, rtx argblock, int *low_to_save, int *high_to_save)
728
{
729
  int low;
730
  int high;
731
 
732
  /* Compute the boundary of the area that needs to be saved, if any.  */
733
  high = reg_parm_stack_space;
734
#ifdef ARGS_GROW_DOWNWARD
735
  high += 1;
736
#endif
737
  if (high > highest_outgoing_arg_in_use)
738
    high = highest_outgoing_arg_in_use;
739
 
740
  for (low = 0; low < high; low++)
741
    if (stack_usage_map[low] != 0)
742
      {
743
        int num_to_save;
744
        enum machine_mode save_mode;
745
        int delta;
746
        rtx stack_area;
747
        rtx save_area;
748
 
749
        while (stack_usage_map[--high] == 0)
750
          ;
751
 
752
        *low_to_save = low;
753
        *high_to_save = high;
754
 
755
        num_to_save = high - low + 1;
756
        save_mode = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1);
757
 
758
        /* If we don't have the required alignment, must do this
759
           in BLKmode.  */
760
        if ((low & (MIN (GET_MODE_SIZE (save_mode),
761
                         BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)))
762
          save_mode = BLKmode;
763
 
764
#ifdef ARGS_GROW_DOWNWARD
765
        delta = -high;
766
#else
767
        delta = low;
768
#endif
769
        stack_area = gen_rtx_MEM (save_mode,
770
                                  memory_address (save_mode,
771
                                                  plus_constant (argblock,
772
                                                                 delta)));
773
 
774
        set_mem_align (stack_area, PARM_BOUNDARY);
775
        if (save_mode == BLKmode)
776
          {
777
            save_area = assign_stack_temp (BLKmode, num_to_save, 0);
778
            emit_block_move (validize_mem (save_area), stack_area,
779
                             GEN_INT (num_to_save), BLOCK_OP_CALL_PARM);
780
          }
781
        else
782
          {
783
            save_area = gen_reg_rtx (save_mode);
784
            emit_move_insn (save_area, stack_area);
785
          }
786
 
787
        return save_area;
788
      }
789
 
790
  return NULL_RTX;
791
}
792
 
793
static void
794
restore_fixed_argument_area (rtx save_area, rtx argblock, int high_to_save, int low_to_save)
795
{
796
  enum machine_mode save_mode = GET_MODE (save_area);
797
  int delta;
798
  rtx stack_area;
799
 
800
#ifdef ARGS_GROW_DOWNWARD
801
  delta = -high_to_save;
802
#else
803
  delta = low_to_save;
804
#endif
805
  stack_area = gen_rtx_MEM (save_mode,
806
                            memory_address (save_mode,
807
                                            plus_constant (argblock, delta)));
808
  set_mem_align (stack_area, PARM_BOUNDARY);
809
 
810
  if (save_mode != BLKmode)
811
    emit_move_insn (stack_area, save_area);
812
  else
813
    emit_block_move (stack_area, validize_mem (save_area),
814
                     GEN_INT (high_to_save - low_to_save + 1),
815
                     BLOCK_OP_CALL_PARM);
816
}
817
#endif /* REG_PARM_STACK_SPACE */
818
 
819
/* If any elements in ARGS refer to parameters that are to be passed in
820
   registers, but not in memory, and whose alignment does not permit a
821
   direct copy into registers.  Copy the values into a group of pseudos
822
   which we will later copy into the appropriate hard registers.
823
 
824
   Pseudos for each unaligned argument will be stored into the array
825
   args[argnum].aligned_regs.  The caller is responsible for deallocating
826
   the aligned_regs array if it is nonzero.  */
827
 
828
static void
829
store_unaligned_arguments_into_pseudos (struct arg_data *args, int num_actuals)
830
{
831
  int i, j;
832
 
833
  for (i = 0; i < num_actuals; i++)
834
    if (args[i].reg != 0 && ! args[i].pass_on_stack
835
        && args[i].mode == BLKmode
836
        && MEM_P (args[i].value)
837
        && (MEM_ALIGN (args[i].value)
838
            < (unsigned int) MIN (BIGGEST_ALIGNMENT, BITS_PER_WORD)))
839
      {
840
        int bytes = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
841
        int endian_correction = 0;
842
 
843
        if (args[i].partial)
844
          {
845
            gcc_assert (args[i].partial % UNITS_PER_WORD == 0);
846
            args[i].n_aligned_regs = args[i].partial / UNITS_PER_WORD;
847
          }
848
        else
849
          {
850
            args[i].n_aligned_regs
851
              = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
852
          }
853
 
854
        args[i].aligned_regs = XNEWVEC (rtx, args[i].n_aligned_regs);
855
 
856
        /* Structures smaller than a word are normally aligned to the
857
           least significant byte.  On a BYTES_BIG_ENDIAN machine,
858
           this means we must skip the empty high order bytes when
859
           calculating the bit offset.  */
860
        if (bytes < UNITS_PER_WORD
861
#ifdef BLOCK_REG_PADDING
862
            && (BLOCK_REG_PADDING (args[i].mode,
863
                                   TREE_TYPE (args[i].tree_value), 1)
864
                == downward)
865
#else
866
            && BYTES_BIG_ENDIAN
867
#endif
868
            )
869
          endian_correction = BITS_PER_WORD - bytes * BITS_PER_UNIT;
870
 
871
        for (j = 0; j < args[i].n_aligned_regs; j++)
872
          {
873
            rtx reg = gen_reg_rtx (word_mode);
874
            rtx word = operand_subword_force (args[i].value, j, BLKmode);
875
            int bitsize = MIN (bytes * BITS_PER_UNIT, BITS_PER_WORD);
876
 
877
            args[i].aligned_regs[j] = reg;
878
            word = extract_bit_field (word, bitsize, 0, 1, NULL_RTX,
879
                                      word_mode, word_mode);
880
 
881
            /* There is no need to restrict this code to loading items
882
               in TYPE_ALIGN sized hunks.  The bitfield instructions can
883
               load up entire word sized registers efficiently.
884
 
885
               ??? This may not be needed anymore.
886
               We use to emit a clobber here but that doesn't let later
887
               passes optimize the instructions we emit.  By storing 0 into
888
               the register later passes know the first AND to zero out the
889
               bitfield being set in the register is unnecessary.  The store
890
               of 0 will be deleted as will at least the first AND.  */
891
 
892
            emit_move_insn (reg, const0_rtx);
893
 
894
            bytes -= bitsize / BITS_PER_UNIT;
895
            store_bit_field (reg, bitsize, endian_correction, word_mode,
896
                             word);
897
          }
898
      }
899
}
900
 
901
/* Fill in ARGS_SIZE and ARGS array based on the parameters found in
902
   CALL_EXPR EXP.
903
 
904
   NUM_ACTUALS is the total number of parameters.
905
 
906
   N_NAMED_ARGS is the total number of named arguments.
907
 
908
   STRUCT_VALUE_ADDR_VALUE is the implicit argument for a struct return
909
   value, or null.
910
 
911
   FNDECL is the tree code for the target of this call (if known)
912
 
913
   ARGS_SO_FAR holds state needed by the target to know where to place
914
   the next argument.
915
 
916
   REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
917
   for arguments which are passed in registers.
918
 
919
   OLD_STACK_LEVEL is a pointer to an rtx which olds the old stack level
920
   and may be modified by this routine.
921
 
922
   OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer
923
   flags which may may be modified by this routine.
924
 
925
   MAY_TAILCALL is cleared if we encounter an invisible pass-by-reference
926
   that requires allocation of stack space.
927
 
928
   CALL_FROM_THUNK_P is true if this call is the jump from a thunk to
929
   the thunked-to function.  */
930
 
931
static void
932
initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
933
                                 struct arg_data *args,
934
                                 struct args_size *args_size,
935
                                 int n_named_args ATTRIBUTE_UNUSED,
936
                                 tree exp, tree struct_value_addr_value,
937
                                 tree fndecl, tree fntype,
938
                                 CUMULATIVE_ARGS *args_so_far,
939
                                 int reg_parm_stack_space,
940
                                 rtx *old_stack_level, int *old_pending_adj,
941
                                 int *must_preallocate, int *ecf_flags,
942
                                 bool *may_tailcall, bool call_from_thunk_p)
943
{
944
  location_t loc = EXPR_LOCATION (exp);
945
  /* 1 if scanning parms front to back, -1 if scanning back to front.  */
946
  int inc;
947
 
948
  /* Count arg position in order args appear.  */
949
  int argpos;
950
 
951
  int i;
952
 
953
  args_size->constant = 0;
954
  args_size->var = 0;
955
 
956
  /* In this loop, we consider args in the order they are written.
957
     We fill up ARGS from the front or from the back if necessary
958
     so that in any case the first arg to be pushed ends up at the front.  */
959
 
960
  if (PUSH_ARGS_REVERSED)
961
    {
962
      i = num_actuals - 1, inc = -1;
963
      /* In this case, must reverse order of args
964
         so that we compute and push the last arg first.  */
965
    }
966
  else
967
    {
968
      i = 0, inc = 1;
969
    }
970
 
971
  /* First fill in the actual arguments in the ARGS array, splitting
972
     complex arguments if necessary.  */
973
  {
974
    int j = i;
975
    call_expr_arg_iterator iter;
976
    tree arg;
977
 
978
    if (struct_value_addr_value)
979
      {
980
        args[j].tree_value = struct_value_addr_value;
981
        j += inc;
982
      }
983
    FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
984
      {
985
        tree argtype = TREE_TYPE (arg);
986
        if (targetm.calls.split_complex_arg
987
            && argtype
988
            && TREE_CODE (argtype) == COMPLEX_TYPE
989
            && targetm.calls.split_complex_arg (argtype))
990
          {
991
            tree subtype = TREE_TYPE (argtype);
992
            args[j].tree_value = build1 (REALPART_EXPR, subtype, arg);
993
            j += inc;
994
            args[j].tree_value = build1 (IMAGPART_EXPR, subtype, arg);
995
          }
996
        else
997
          args[j].tree_value = arg;
998
        j += inc;
999
      }
1000
  }
1001
 
1002
  /* I counts args in order (to be) pushed; ARGPOS counts in order written.  */
1003
  for (argpos = 0; argpos < num_actuals; i += inc, argpos++)
1004
    {
1005
      tree type = TREE_TYPE (args[i].tree_value);
1006
      int unsignedp;
1007
      enum machine_mode mode;
1008
 
1009
      /* Replace erroneous argument with constant zero.  */
1010
      if (type == error_mark_node || !COMPLETE_TYPE_P (type))
1011
        args[i].tree_value = integer_zero_node, type = integer_type_node;
1012
 
1013
      /* If TYPE is a transparent union or record, pass things the way
1014
         we would pass the first field of the union or record.  We have
1015
         already verified that the modes are the same.  */
1016
      if ((TREE_CODE (type) == UNION_TYPE || TREE_CODE (type) == RECORD_TYPE)
1017
           && TYPE_TRANSPARENT_AGGR (type))
1018
        type = TREE_TYPE (first_field (type));
1019
 
1020
      /* Decide where to pass this arg.
1021
 
1022
         args[i].reg is nonzero if all or part is passed in registers.
1023
 
1024
         args[i].partial is nonzero if part but not all is passed in registers,
1025
         and the exact value says how many bytes are passed in registers.
1026
 
1027
         args[i].pass_on_stack is nonzero if the argument must at least be
1028
         computed on the stack.  It may then be loaded back into registers
1029
         if args[i].reg is nonzero.
1030
 
1031
         These decisions are driven by the FUNCTION_... macros and must agree
1032
         with those made by function.c.  */
1033
 
1034
      /* See if this argument should be passed by invisible reference.  */
1035
      if (pass_by_reference (args_so_far, TYPE_MODE (type),
1036
                             type, argpos < n_named_args))
1037
        {
1038
          bool callee_copies;
1039
          tree base;
1040
 
1041
          callee_copies
1042
            = reference_callee_copied (args_so_far, TYPE_MODE (type),
1043
                                       type, argpos < n_named_args);
1044
 
1045
          /* If we're compiling a thunk, pass through invisible references
1046
             instead of making a copy.  */
1047
          if (call_from_thunk_p
1048
              || (callee_copies
1049
                  && !TREE_ADDRESSABLE (type)
1050
                  && (base = get_base_address (args[i].tree_value))
1051
                  && TREE_CODE (base) != SSA_NAME
1052
                  && (!DECL_P (base) || MEM_P (DECL_RTL (base)))))
1053
            {
1054
              /* We can't use sibcalls if a callee-copied argument is
1055
                 stored in the current function's frame.  */
1056
              if (!call_from_thunk_p && DECL_P (base) && !TREE_STATIC (base))
1057
                *may_tailcall = false;
1058
 
1059
              args[i].tree_value = build_fold_addr_expr_loc (loc,
1060
                                                         args[i].tree_value);
1061
              type = TREE_TYPE (args[i].tree_value);
1062
 
1063
              if (*ecf_flags & ECF_CONST)
1064
                *ecf_flags &= ~(ECF_CONST | ECF_LOOPING_CONST_OR_PURE);
1065
            }
1066
          else
1067
            {
1068
              /* We make a copy of the object and pass the address to the
1069
                 function being called.  */
1070
              rtx copy;
1071
 
1072
              if (!COMPLETE_TYPE_P (type)
1073
                  || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST
1074
                  || (flag_stack_check == GENERIC_STACK_CHECK
1075
                      && compare_tree_int (TYPE_SIZE_UNIT (type),
1076
                                           STACK_CHECK_MAX_VAR_SIZE) > 0))
1077
                {
1078
                  /* This is a variable-sized object.  Make space on the stack
1079
                     for it.  */
1080
                  rtx size_rtx = expr_size (args[i].tree_value);
1081
 
1082
                  if (*old_stack_level == 0)
1083
                    {
1084
                      emit_stack_save (SAVE_BLOCK, old_stack_level, NULL_RTX);
1085
                      *old_pending_adj = pending_stack_adjust;
1086
                      pending_stack_adjust = 0;
1087
                    }
1088
 
1089
                  copy = gen_rtx_MEM (BLKmode,
1090
                                      allocate_dynamic_stack_space
1091
                                      (size_rtx, NULL_RTX, TYPE_ALIGN (type)));
1092
                  set_mem_attributes (copy, type, 1);
1093
                }
1094
              else
1095
                copy = assign_temp (type, 0, 1, 0);
1096
 
1097
              store_expr (args[i].tree_value, copy, 0, false);
1098
 
1099
              /* Just change the const function to pure and then let
1100
                 the next test clear the pure based on
1101
                 callee_copies.  */
1102
              if (*ecf_flags & ECF_CONST)
1103
                {
1104
                  *ecf_flags &= ~ECF_CONST;
1105
                  *ecf_flags |= ECF_PURE;
1106
                }
1107
 
1108
              if (!callee_copies && *ecf_flags & ECF_PURE)
1109
                *ecf_flags &= ~(ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
1110
 
1111
              args[i].tree_value
1112
                = build_fold_addr_expr_loc (loc, make_tree (type, copy));
1113
              type = TREE_TYPE (args[i].tree_value);
1114
              *may_tailcall = false;
1115
            }
1116
        }
1117
 
1118
      unsignedp = TYPE_UNSIGNED (type);
1119
      mode = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
1120
                                    fndecl ? TREE_TYPE (fndecl) : fntype, 0);
1121
 
1122
      args[i].unsignedp = unsignedp;
1123
      args[i].mode = mode;
1124
 
1125
      args[i].reg = FUNCTION_ARG (*args_so_far, mode, type,
1126
                                  argpos < n_named_args);
1127
#ifdef FUNCTION_INCOMING_ARG
1128
      /* If this is a sibling call and the machine has register windows, the
1129
         register window has to be unwinded before calling the routine, so
1130
         arguments have to go into the incoming registers.  */
1131
      args[i].tail_call_reg = FUNCTION_INCOMING_ARG (*args_so_far, mode, type,
1132
                                                     argpos < n_named_args);
1133
#else
1134
      args[i].tail_call_reg = args[i].reg;
1135
#endif
1136
 
1137
      if (args[i].reg)
1138
        args[i].partial
1139
          = targetm.calls.arg_partial_bytes (args_so_far, mode, type,
1140
                                             argpos < n_named_args);
1141
 
1142
      args[i].pass_on_stack = targetm.calls.must_pass_in_stack (mode, type);
1143
 
1144
      /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
1145
         it means that we are to pass this arg in the register(s) designated
1146
         by the PARALLEL, but also to pass it in the stack.  */
1147
      if (args[i].reg && GET_CODE (args[i].reg) == PARALLEL
1148
          && XEXP (XVECEXP (args[i].reg, 0, 0), 0) == 0)
1149
        args[i].pass_on_stack = 1;
1150
 
1151
      /* If this is an addressable type, we must preallocate the stack
1152
         since we must evaluate the object into its final location.
1153
 
1154
         If this is to be passed in both registers and the stack, it is simpler
1155
         to preallocate.  */
1156
      if (TREE_ADDRESSABLE (type)
1157
          || (args[i].pass_on_stack && args[i].reg != 0))
1158
        *must_preallocate = 1;
1159
 
1160
      /* Compute the stack-size of this argument.  */
1161
      if (args[i].reg == 0 || args[i].partial != 0
1162
          || reg_parm_stack_space > 0
1163
          || args[i].pass_on_stack)
1164
        locate_and_pad_parm (mode, type,
1165
#ifdef STACK_PARMS_IN_REG_PARM_AREA
1166
                             1,
1167
#else
1168
                             args[i].reg != 0,
1169
#endif
1170
                             args[i].pass_on_stack ? 0 : args[i].partial,
1171
                             fndecl, args_size, &args[i].locate);
1172
#ifdef BLOCK_REG_PADDING
1173
      else
1174
        /* The argument is passed entirely in registers.  See at which
1175
           end it should be padded.  */
1176
        args[i].locate.where_pad =
1177
          BLOCK_REG_PADDING (mode, type,
1178
                             int_size_in_bytes (type) <= UNITS_PER_WORD);
1179
#endif
1180
 
1181
      /* Update ARGS_SIZE, the total stack space for args so far.  */
1182
 
1183
      args_size->constant += args[i].locate.size.constant;
1184
      if (args[i].locate.size.var)
1185
        ADD_PARM_SIZE (*args_size, args[i].locate.size.var);
1186
 
1187
      /* Increment ARGS_SO_FAR, which has info about which arg-registers
1188
         have been used, etc.  */
1189
 
1190
      FUNCTION_ARG_ADVANCE (*args_so_far, TYPE_MODE (type), type,
1191
                            argpos < n_named_args);
1192
    }
1193
}
1194
 
1195
/* Update ARGS_SIZE to contain the total size for the argument block.
1196
   Return the original constant component of the argument block's size.
1197
 
1198
   REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
1199
   for arguments passed in registers.  */
1200
 
1201
static int
1202
compute_argument_block_size (int reg_parm_stack_space,
1203
                             struct args_size *args_size,
1204
                             tree fndecl ATTRIBUTE_UNUSED,
1205
                             tree fntype ATTRIBUTE_UNUSED,
1206
                             int preferred_stack_boundary ATTRIBUTE_UNUSED)
1207
{
1208
  int unadjusted_args_size = args_size->constant;
1209
 
1210
  /* For accumulate outgoing args mode we don't need to align, since the frame
1211
     will be already aligned.  Align to STACK_BOUNDARY in order to prevent
1212
     backends from generating misaligned frame sizes.  */
1213
  if (ACCUMULATE_OUTGOING_ARGS && preferred_stack_boundary > STACK_BOUNDARY)
1214
    preferred_stack_boundary = STACK_BOUNDARY;
1215
 
1216
  /* Compute the actual size of the argument block required.  The variable
1217
     and constant sizes must be combined, the size may have to be rounded,
1218
     and there may be a minimum required size.  */
1219
 
1220
  if (args_size->var)
1221
    {
1222
      args_size->var = ARGS_SIZE_TREE (*args_size);
1223
      args_size->constant = 0;
1224
 
1225
      preferred_stack_boundary /= BITS_PER_UNIT;
1226
      if (preferred_stack_boundary > 1)
1227
        {
1228
          /* We don't handle this case yet.  To handle it correctly we have
1229
             to add the delta, round and subtract the delta.
1230
             Currently no machine description requires this support.  */
1231
          gcc_assert (!(stack_pointer_delta & (preferred_stack_boundary - 1)));
1232
          args_size->var = round_up (args_size->var, preferred_stack_boundary);
1233
        }
1234
 
1235
      if (reg_parm_stack_space > 0)
1236
        {
1237
          args_size->var
1238
            = size_binop (MAX_EXPR, args_size->var,
1239
                          ssize_int (reg_parm_stack_space));
1240
 
1241
          /* The area corresponding to register parameters is not to count in
1242
             the size of the block we need.  So make the adjustment.  */
1243
          if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
1244
            args_size->var
1245
              = size_binop (MINUS_EXPR, args_size->var,
1246
                            ssize_int (reg_parm_stack_space));
1247
        }
1248
    }
1249
  else
1250
    {
1251
      preferred_stack_boundary /= BITS_PER_UNIT;
1252
      if (preferred_stack_boundary < 1)
1253
        preferred_stack_boundary = 1;
1254
      args_size->constant = (((args_size->constant
1255
                               + stack_pointer_delta
1256
                               + preferred_stack_boundary - 1)
1257
                              / preferred_stack_boundary
1258
                              * preferred_stack_boundary)
1259
                             - stack_pointer_delta);
1260
 
1261
      args_size->constant = MAX (args_size->constant,
1262
                                 reg_parm_stack_space);
1263
 
1264
      if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
1265
        args_size->constant -= reg_parm_stack_space;
1266
    }
1267
  return unadjusted_args_size;
1268
}
1269
 
1270
/* Precompute parameters as needed for a function call.
1271
 
1272
   FLAGS is mask of ECF_* constants.
1273
 
1274
   NUM_ACTUALS is the number of arguments.
1275
 
1276
   ARGS is an array containing information for each argument; this
1277
   routine fills in the INITIAL_VALUE and VALUE fields for each
1278
   precomputed argument.  */
1279
 
1280
static void
1281
precompute_arguments (int num_actuals, struct arg_data *args)
1282
{
1283
  int i;
1284
 
1285
  /* If this is a libcall, then precompute all arguments so that we do not
1286
     get extraneous instructions emitted as part of the libcall sequence.  */
1287
 
1288
  /* If we preallocated the stack space, and some arguments must be passed
1289
     on the stack, then we must precompute any parameter which contains a
1290
     function call which will store arguments on the stack.
1291
     Otherwise, evaluating the parameter may clobber previous parameters
1292
     which have already been stored into the stack.  (we have code to avoid
1293
     such case by saving the outgoing stack arguments, but it results in
1294
     worse code)  */
1295
  if (!ACCUMULATE_OUTGOING_ARGS)
1296
    return;
1297
 
1298
  for (i = 0; i < num_actuals; i++)
1299
    {
1300
      tree type;
1301
      enum machine_mode mode;
1302
 
1303
      if (TREE_CODE (args[i].tree_value) != CALL_EXPR)
1304
        continue;
1305
 
1306
      /* If this is an addressable type, we cannot pre-evaluate it.  */
1307
      type = TREE_TYPE (args[i].tree_value);
1308
      gcc_assert (!TREE_ADDRESSABLE (type));
1309
 
1310
      args[i].initial_value = args[i].value
1311
        = expand_normal (args[i].tree_value);
1312
 
1313
      mode = TYPE_MODE (type);
1314
      if (mode != args[i].mode)
1315
        {
1316
          int unsignedp = args[i].unsignedp;
1317
          args[i].value
1318
            = convert_modes (args[i].mode, mode,
1319
                             args[i].value, args[i].unsignedp);
1320
 
1321
          /* CSE will replace this only if it contains args[i].value
1322
             pseudo, so convert it down to the declared mode using
1323
             a SUBREG.  */
1324
          if (REG_P (args[i].value)
1325
              && GET_MODE_CLASS (args[i].mode) == MODE_INT
1326
              && promote_mode (type, mode, &unsignedp) != args[i].mode)
1327
            {
1328
              args[i].initial_value
1329
                = gen_lowpart_SUBREG (mode, args[i].value);
1330
              SUBREG_PROMOTED_VAR_P (args[i].initial_value) = 1;
1331
              SUBREG_PROMOTED_UNSIGNED_SET (args[i].initial_value,
1332
                                            args[i].unsignedp);
1333
            }
1334
        }
1335
    }
1336
}
1337
 
1338
/* Given the current state of MUST_PREALLOCATE and information about
1339
   arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
1340
   compute and return the final value for MUST_PREALLOCATE.  */
1341
 
1342
static int
1343
finalize_must_preallocate (int must_preallocate, int num_actuals,
1344
                           struct arg_data *args, struct args_size *args_size)
1345
{
1346
  /* See if we have or want to preallocate stack space.
1347
 
1348
     If we would have to push a partially-in-regs parm
1349
     before other stack parms, preallocate stack space instead.
1350
 
1351
     If the size of some parm is not a multiple of the required stack
1352
     alignment, we must preallocate.
1353
 
1354
     If the total size of arguments that would otherwise create a copy in
1355
     a temporary (such as a CALL) is more than half the total argument list
1356
     size, preallocation is faster.
1357
 
1358
     Another reason to preallocate is if we have a machine (like the m88k)
1359
     where stack alignment is required to be maintained between every
1360
     pair of insns, not just when the call is made.  However, we assume here
1361
     that such machines either do not have push insns (and hence preallocation
1362
     would occur anyway) or the problem is taken care of with
1363
     PUSH_ROUNDING.  */
1364
 
1365
  if (! must_preallocate)
1366
    {
1367
      int partial_seen = 0;
1368
      int copy_to_evaluate_size = 0;
1369
      int i;
1370
 
1371
      for (i = 0; i < num_actuals && ! must_preallocate; i++)
1372
        {
1373
          if (args[i].partial > 0 && ! args[i].pass_on_stack)
1374
            partial_seen = 1;
1375
          else if (partial_seen && args[i].reg == 0)
1376
            must_preallocate = 1;
1377
 
1378
          if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1379
              && (TREE_CODE (args[i].tree_value) == CALL_EXPR
1380
                  || TREE_CODE (args[i].tree_value) == TARGET_EXPR
1381
                  || TREE_CODE (args[i].tree_value) == COND_EXPR
1382
                  || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
1383
            copy_to_evaluate_size
1384
              += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1385
        }
1386
 
1387
      if (copy_to_evaluate_size * 2 >= args_size->constant
1388
          && args_size->constant > 0)
1389
        must_preallocate = 1;
1390
    }
1391
  return must_preallocate;
1392
}
1393
 
1394
/* If we preallocated stack space, compute the address of each argument
1395
   and store it into the ARGS array.
1396
 
1397
   We need not ensure it is a valid memory address here; it will be
1398
   validized when it is used.
1399
 
1400
   ARGBLOCK is an rtx for the address of the outgoing arguments.  */
1401
 
1402
static void
1403
compute_argument_addresses (struct arg_data *args, rtx argblock, int num_actuals)
1404
{
1405
  if (argblock)
1406
    {
1407
      rtx arg_reg = argblock;
1408
      int i, arg_offset = 0;
1409
 
1410
      if (GET_CODE (argblock) == PLUS)
1411
        arg_reg = XEXP (argblock, 0), arg_offset = INTVAL (XEXP (argblock, 1));
1412
 
1413
      for (i = 0; i < num_actuals; i++)
1414
        {
1415
          rtx offset = ARGS_SIZE_RTX (args[i].locate.offset);
1416
          rtx slot_offset = ARGS_SIZE_RTX (args[i].locate.slot_offset);
1417
          rtx addr;
1418
          unsigned int align, boundary;
1419
          unsigned int units_on_stack = 0;
1420
          enum machine_mode partial_mode = VOIDmode;
1421
 
1422
          /* Skip this parm if it will not be passed on the stack.  */
1423
          if (! args[i].pass_on_stack
1424
              && args[i].reg != 0
1425
              && args[i].partial == 0)
1426
            continue;
1427
 
1428
          if (CONST_INT_P (offset))
1429
            addr = plus_constant (arg_reg, INTVAL (offset));
1430
          else
1431
            addr = gen_rtx_PLUS (Pmode, arg_reg, offset);
1432
 
1433
          addr = plus_constant (addr, arg_offset);
1434
 
1435
          if (args[i].partial != 0)
1436
            {
1437
              /* Only part of the parameter is being passed on the stack.
1438
                 Generate a simple memory reference of the correct size.  */
1439
              units_on_stack = args[i].locate.size.constant;
1440
              partial_mode = mode_for_size (units_on_stack * BITS_PER_UNIT,
1441
                                            MODE_INT, 1);
1442
              args[i].stack = gen_rtx_MEM (partial_mode, addr);
1443
              set_mem_size (args[i].stack, GEN_INT (units_on_stack));
1444
            }
1445
          else
1446
            {
1447
              args[i].stack = gen_rtx_MEM (args[i].mode, addr);
1448
              set_mem_attributes (args[i].stack,
1449
                                  TREE_TYPE (args[i].tree_value), 1);
1450
            }
1451
          align = BITS_PER_UNIT;
1452
          boundary = args[i].locate.boundary;
1453
          if (args[i].locate.where_pad != downward)
1454
            align = boundary;
1455
          else if (CONST_INT_P (offset))
1456
            {
1457
              align = INTVAL (offset) * BITS_PER_UNIT | boundary;
1458
              align = align & -align;
1459
            }
1460
          set_mem_align (args[i].stack, align);
1461
 
1462
          if (CONST_INT_P (slot_offset))
1463
            addr = plus_constant (arg_reg, INTVAL (slot_offset));
1464
          else
1465
            addr = gen_rtx_PLUS (Pmode, arg_reg, slot_offset);
1466
 
1467
          addr = plus_constant (addr, arg_offset);
1468
 
1469
          if (args[i].partial != 0)
1470
            {
1471
              /* Only part of the parameter is being passed on the stack.
1472
                 Generate a simple memory reference of the correct size.
1473
               */
1474
              args[i].stack_slot = gen_rtx_MEM (partial_mode, addr);
1475
              set_mem_size (args[i].stack_slot, GEN_INT (units_on_stack));
1476
            }
1477
          else
1478
            {
1479
              args[i].stack_slot = gen_rtx_MEM (args[i].mode, addr);
1480
              set_mem_attributes (args[i].stack_slot,
1481
                                  TREE_TYPE (args[i].tree_value), 1);
1482
            }
1483
          set_mem_align (args[i].stack_slot, args[i].locate.boundary);
1484
 
1485
          /* Function incoming arguments may overlap with sibling call
1486
             outgoing arguments and we cannot allow reordering of reads
1487
             from function arguments with stores to outgoing arguments
1488
             of sibling calls.  */
1489
          set_mem_alias_set (args[i].stack, 0);
1490
          set_mem_alias_set (args[i].stack_slot, 0);
1491
        }
1492
    }
1493
}
1494
 
1495
/* Given a FNDECL and EXP, return an rtx suitable for use as a target address
1496
   in a call instruction.
1497
 
1498
   FNDECL is the tree node for the target function.  For an indirect call
1499
   FNDECL will be NULL_TREE.
1500
 
1501
   ADDR is the operand 0 of CALL_EXPR for this call.  */
1502
 
1503
static rtx
1504
rtx_for_function_call (tree fndecl, tree addr)
1505
{
1506
  rtx funexp;
1507
 
1508
  /* Get the function to call, in the form of RTL.  */
1509
  if (fndecl)
1510
    {
1511
      /* If this is the first use of the function, see if we need to
1512
         make an external definition for it.  */
1513
      if (!TREE_USED (fndecl) && fndecl != current_function_decl)
1514
        {
1515
          assemble_external (fndecl);
1516
          TREE_USED (fndecl) = 1;
1517
        }
1518
 
1519
      /* Get a SYMBOL_REF rtx for the function address.  */
1520
      funexp = XEXP (DECL_RTL (fndecl), 0);
1521
    }
1522
  else
1523
    /* Generate an rtx (probably a pseudo-register) for the address.  */
1524
    {
1525
      push_temp_slots ();
1526
      funexp = expand_normal (addr);
1527
      pop_temp_slots ();        /* FUNEXP can't be BLKmode.  */
1528
    }
1529
  return funexp;
1530
}
1531
 
1532
/* Return true if and only if SIZE storage units (usually bytes)
1533
   starting from address ADDR overlap with already clobbered argument
1534
   area.  This function is used to determine if we should give up a
1535
   sibcall.  */
1536
 
1537
static bool
1538
mem_overlaps_already_clobbered_arg_p (rtx addr, unsigned HOST_WIDE_INT size)
1539
{
1540
  HOST_WIDE_INT i;
1541
 
1542
  if (addr == crtl->args.internal_arg_pointer)
1543
    i = 0;
1544
  else if (GET_CODE (addr) == PLUS
1545
           && XEXP (addr, 0) == crtl->args.internal_arg_pointer
1546
           && CONST_INT_P (XEXP (addr, 1)))
1547
    i = INTVAL (XEXP (addr, 1));
1548
  /* Return true for arg pointer based indexed addressing.  */
1549
  else if (GET_CODE (addr) == PLUS
1550
           && (XEXP (addr, 0) == crtl->args.internal_arg_pointer
1551
               || XEXP (addr, 1) == crtl->args.internal_arg_pointer))
1552
    return true;
1553
  else
1554
    return false;
1555
 
1556
#ifdef ARGS_GROW_DOWNWARD
1557
  i = -i - size;
1558
#endif
1559
  if (size > 0)
1560
    {
1561
      unsigned HOST_WIDE_INT k;
1562
 
1563
      for (k = 0; k < size; k++)
1564
        if (i + k < stored_args_map->n_bits
1565
            && TEST_BIT (stored_args_map, i + k))
1566
          return true;
1567
    }
1568
 
1569
  return false;
1570
}
1571
 
1572
/* Do the register loads required for any wholly-register parms or any
1573
   parms which are passed both on the stack and in a register.  Their
1574
   expressions were already evaluated.
1575
 
1576
   Mark all register-parms as living through the call, putting these USE
1577
   insns in the CALL_INSN_FUNCTION_USAGE field.
1578
 
1579
   When IS_SIBCALL, perform the check_sibcall_argument_overlap
1580
   checking, setting *SIBCALL_FAILURE if appropriate.  */
1581
 
1582
static void
1583
load_register_parameters (struct arg_data *args, int num_actuals,
1584
                          rtx *call_fusage, int flags, int is_sibcall,
1585
                          int *sibcall_failure)
1586
{
1587
  int i, j;
1588
 
1589
  for (i = 0; i < num_actuals; i++)
1590
    {
1591
      rtx reg = ((flags & ECF_SIBCALL)
1592
                 ? args[i].tail_call_reg : args[i].reg);
1593
      if (reg)
1594
        {
1595
          int partial = args[i].partial;
1596
          int nregs;
1597
          int size = 0;
1598
          rtx before_arg = get_last_insn ();
1599
          /* Set non-negative if we must move a word at a time, even if
1600
             just one word (e.g, partial == 4 && mode == DFmode).  Set
1601
             to -1 if we just use a normal move insn.  This value can be
1602
             zero if the argument is a zero size structure.  */
1603
          nregs = -1;
1604
          if (GET_CODE (reg) == PARALLEL)
1605
            ;
1606
          else if (partial)
1607
            {
1608
              gcc_assert (partial % UNITS_PER_WORD == 0);
1609
              nregs = partial / UNITS_PER_WORD;
1610
            }
1611
          else if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode)
1612
            {
1613
              size = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1614
              nregs = (size + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
1615
            }
1616
          else
1617
            size = GET_MODE_SIZE (args[i].mode);
1618
 
1619
          /* Handle calls that pass values in multiple non-contiguous
1620
             locations.  The Irix 6 ABI has examples of this.  */
1621
 
1622
          if (GET_CODE (reg) == PARALLEL)
1623
            emit_group_move (reg, args[i].parallel_value);
1624
 
1625
          /* If simple case, just do move.  If normal partial, store_one_arg
1626
             has already loaded the register for us.  In all other cases,
1627
             load the register(s) from memory.  */
1628
 
1629
          else if (nregs == -1)
1630
            {
1631
              emit_move_insn (reg, args[i].value);
1632
#ifdef BLOCK_REG_PADDING
1633
              /* Handle case where we have a value that needs shifting
1634
                 up to the msb.  eg. a QImode value and we're padding
1635
                 upward on a BYTES_BIG_ENDIAN machine.  */
1636
              if (size < UNITS_PER_WORD
1637
                  && (args[i].locate.where_pad
1638
                      == (BYTES_BIG_ENDIAN ? upward : downward)))
1639
                {
1640
                  rtx x;
1641
                  int shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
1642
 
1643
                  /* Assigning REG here rather than a temp makes CALL_FUSAGE
1644
                     report the whole reg as used.  Strictly speaking, the
1645
                     call only uses SIZE bytes at the msb end, but it doesn't
1646
                     seem worth generating rtl to say that.  */
1647
                  reg = gen_rtx_REG (word_mode, REGNO (reg));
1648
                  x = expand_shift (LSHIFT_EXPR, word_mode, reg,
1649
                                    build_int_cst (NULL_TREE, shift),
1650
                                    reg, 1);
1651
                  if (x != reg)
1652
                    emit_move_insn (reg, x);
1653
                }
1654
#endif
1655
            }
1656
 
1657
          /* If we have pre-computed the values to put in the registers in
1658
             the case of non-aligned structures, copy them in now.  */
1659
 
1660
          else if (args[i].n_aligned_regs != 0)
1661
            for (j = 0; j < args[i].n_aligned_regs; j++)
1662
              emit_move_insn (gen_rtx_REG (word_mode, REGNO (reg) + j),
1663
                              args[i].aligned_regs[j]);
1664
 
1665
          else if (partial == 0 || args[i].pass_on_stack)
1666
            {
1667
              rtx mem = validize_mem (args[i].value);
1668
 
1669
              /* Check for overlap with already clobbered argument area.  */
1670
              if (is_sibcall
1671
                  && mem_overlaps_already_clobbered_arg_p (XEXP (args[i].value, 0),
1672
                                                           size))
1673
                *sibcall_failure = 1;
1674
 
1675
              /* Handle a BLKmode that needs shifting.  */
1676
              if (nregs == 1 && size < UNITS_PER_WORD
1677
#ifdef BLOCK_REG_PADDING
1678
                  && args[i].locate.where_pad == downward
1679
#else
1680
                  && BYTES_BIG_ENDIAN
1681
#endif
1682
                 )
1683
                {
1684
                  rtx tem = operand_subword_force (mem, 0, args[i].mode);
1685
                  rtx ri = gen_rtx_REG (word_mode, REGNO (reg));
1686
                  rtx x = gen_reg_rtx (word_mode);
1687
                  int shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
1688
                  enum tree_code dir = BYTES_BIG_ENDIAN ? RSHIFT_EXPR
1689
                                                        : LSHIFT_EXPR;
1690
 
1691
                  emit_move_insn (x, tem);
1692
                  x = expand_shift (dir, word_mode, x,
1693
                                    build_int_cst (NULL_TREE, shift),
1694
                                    ri, 1);
1695
                  if (x != ri)
1696
                    emit_move_insn (ri, x);
1697
                }
1698
              else
1699
                move_block_to_reg (REGNO (reg), mem, nregs, args[i].mode);
1700
            }
1701
 
1702
          /* When a parameter is a block, and perhaps in other cases, it is
1703
             possible that it did a load from an argument slot that was
1704
             already clobbered.  */
1705
          if (is_sibcall
1706
              && check_sibcall_argument_overlap (before_arg, &args[i], 0))
1707
            *sibcall_failure = 1;
1708
 
1709
          /* Handle calls that pass values in multiple non-contiguous
1710
             locations.  The Irix 6 ABI has examples of this.  */
1711
          if (GET_CODE (reg) == PARALLEL)
1712
            use_group_regs (call_fusage, reg);
1713
          else if (nregs == -1)
1714
            use_reg (call_fusage, reg);
1715
          else if (nregs > 0)
1716
            use_regs (call_fusage, REGNO (reg), nregs);
1717
        }
1718
    }
1719
}
1720
 
1721
/* We need to pop PENDING_STACK_ADJUST bytes.  But, if the arguments
1722
   wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY
1723
   bytes, then we would need to push some additional bytes to pad the
1724
   arguments.  So, we compute an adjust to the stack pointer for an
1725
   amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE
1726
   bytes.  Then, when the arguments are pushed the stack will be perfectly
1727
   aligned.  ARGS_SIZE->CONSTANT is set to the number of bytes that should
1728
   be popped after the call.  Returns the adjustment.  */
1729
 
1730
static int
1731
combine_pending_stack_adjustment_and_call (int unadjusted_args_size,
1732
                                           struct args_size *args_size,
1733
                                           unsigned int preferred_unit_stack_boundary)
1734
{
1735
  /* The number of bytes to pop so that the stack will be
1736
     under-aligned by UNADJUSTED_ARGS_SIZE bytes.  */
1737
  HOST_WIDE_INT adjustment;
1738
  /* The alignment of the stack after the arguments are pushed, if we
1739
     just pushed the arguments without adjust the stack here.  */
1740
  unsigned HOST_WIDE_INT unadjusted_alignment;
1741
 
1742
  unadjusted_alignment
1743
    = ((stack_pointer_delta + unadjusted_args_size)
1744
       % preferred_unit_stack_boundary);
1745
 
1746
  /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes
1747
     as possible -- leaving just enough left to cancel out the
1748
     UNADJUSTED_ALIGNMENT.  In other words, we want to ensure that the
1749
     PENDING_STACK_ADJUST is non-negative, and congruent to
1750
     -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY.  */
1751
 
1752
  /* Begin by trying to pop all the bytes.  */
1753
  unadjusted_alignment
1754
    = (unadjusted_alignment
1755
       - (pending_stack_adjust % preferred_unit_stack_boundary));
1756
  adjustment = pending_stack_adjust;
1757
  /* Push enough additional bytes that the stack will be aligned
1758
     after the arguments are pushed.  */
1759
  if (preferred_unit_stack_boundary > 1)
1760
    {
1761
      if (unadjusted_alignment > 0)
1762
        adjustment -= preferred_unit_stack_boundary - unadjusted_alignment;
1763
      else
1764
        adjustment += unadjusted_alignment;
1765
    }
1766
 
1767
  /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of
1768
     bytes after the call.  The right number is the entire
1769
     PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required
1770
     by the arguments in the first place.  */
1771
  args_size->constant
1772
    = pending_stack_adjust - adjustment + unadjusted_args_size;
1773
 
1774
  return adjustment;
1775
}
1776
 
1777
/* Scan X expression if it does not dereference any argument slots
1778
   we already clobbered by tail call arguments (as noted in stored_args_map
1779
   bitmap).
1780
   Return nonzero if X expression dereferences such argument slots,
1781
   zero otherwise.  */
1782
 
1783
static int
1784
check_sibcall_argument_overlap_1 (rtx x)
1785
{
1786
  RTX_CODE code;
1787
  int i, j;
1788
  const char *fmt;
1789
 
1790
  if (x == NULL_RTX)
1791
    return 0;
1792
 
1793
  code = GET_CODE (x);
1794
 
1795
  if (code == MEM)
1796
    return mem_overlaps_already_clobbered_arg_p (XEXP (x, 0),
1797
                                                 GET_MODE_SIZE (GET_MODE (x)));
1798
 
1799
  /* Scan all subexpressions.  */
1800
  fmt = GET_RTX_FORMAT (code);
1801
  for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
1802
    {
1803
      if (*fmt == 'e')
1804
        {
1805
          if (check_sibcall_argument_overlap_1 (XEXP (x, i)))
1806
            return 1;
1807
        }
1808
      else if (*fmt == 'E')
1809
        {
1810
          for (j = 0; j < XVECLEN (x, i); j++)
1811
            if (check_sibcall_argument_overlap_1 (XVECEXP (x, i, j)))
1812
              return 1;
1813
        }
1814
    }
1815
  return 0;
1816
}
1817
 
1818
/* Scan sequence after INSN if it does not dereference any argument slots
1819
   we already clobbered by tail call arguments (as noted in stored_args_map
1820
   bitmap).  If MARK_STORED_ARGS_MAP, add stack slots for ARG to
1821
   stored_args_map bitmap afterwards (when ARG is a register MARK_STORED_ARGS_MAP
1822
   should be 0).  Return nonzero if sequence after INSN dereferences such argument
1823
   slots, zero otherwise.  */
1824
 
1825
static int
1826
check_sibcall_argument_overlap (rtx insn, struct arg_data *arg, int mark_stored_args_map)
1827
{
1828
  int low, high;
1829
 
1830
  if (insn == NULL_RTX)
1831
    insn = get_insns ();
1832
  else
1833
    insn = NEXT_INSN (insn);
1834
 
1835
  for (; insn; insn = NEXT_INSN (insn))
1836
    if (INSN_P (insn)
1837
        && check_sibcall_argument_overlap_1 (PATTERN (insn)))
1838
      break;
1839
 
1840
  if (mark_stored_args_map)
1841
    {
1842
#ifdef ARGS_GROW_DOWNWARD
1843
      low = -arg->locate.slot_offset.constant - arg->locate.size.constant;
1844
#else
1845
      low = arg->locate.slot_offset.constant;
1846
#endif
1847
 
1848
      for (high = low + arg->locate.size.constant; low < high; low++)
1849
        SET_BIT (stored_args_map, low);
1850
    }
1851
  return insn != NULL_RTX;
1852
}
1853
 
1854
/* Given that a function returns a value of mode MODE at the most
1855
   significant end of hard register VALUE, shift VALUE left or right
1856
   as specified by LEFT_P.  Return true if some action was needed.  */
1857
 
1858
bool
1859
shift_return_value (enum machine_mode mode, bool left_p, rtx value)
1860
{
1861
  HOST_WIDE_INT shift;
1862
 
1863
  gcc_assert (REG_P (value) && HARD_REGISTER_P (value));
1864
  shift = GET_MODE_BITSIZE (GET_MODE (value)) - GET_MODE_BITSIZE (mode);
1865
  if (shift == 0)
1866
    return false;
1867
 
1868
  /* Use ashr rather than lshr for right shifts.  This is for the benefit
1869
     of the MIPS port, which requires SImode values to be sign-extended
1870
     when stored in 64-bit registers.  */
1871
  if (!force_expand_binop (GET_MODE (value), left_p ? ashl_optab : ashr_optab,
1872
                           value, GEN_INT (shift), value, 1, OPTAB_WIDEN))
1873
    gcc_unreachable ();
1874
  return true;
1875
}
1876
 
1877
/* If X is a likely-spilled register value, copy it to a pseudo
1878
   register and return that register.  Return X otherwise.  */
1879
 
1880
static rtx
1881
avoid_likely_spilled_reg (rtx x)
1882
{
1883
  rtx new_rtx;
1884
 
1885
  if (REG_P (x)
1886
      && HARD_REGISTER_P (x)
1887
      && CLASS_LIKELY_SPILLED_P (REGNO_REG_CLASS (REGNO (x))))
1888
    {
1889
      /* Make sure that we generate a REG rather than a CONCAT.
1890
         Moves into CONCATs can need nontrivial instructions,
1891
         and the whole point of this function is to avoid
1892
         using the hard register directly in such a situation.  */
1893
      generating_concat_p = 0;
1894
      new_rtx = gen_reg_rtx (GET_MODE (x));
1895
      generating_concat_p = 1;
1896
      emit_move_insn (new_rtx, x);
1897
      return new_rtx;
1898
    }
1899
  return x;
1900
}
1901
 
1902
/* Generate all the code for a CALL_EXPR exp
1903
   and return an rtx for its value.
1904
   Store the value in TARGET (specified as an rtx) if convenient.
1905
   If the value is stored in TARGET then TARGET is returned.
1906
   If IGNORE is nonzero, then we ignore the value of the function call.  */
1907
 
1908
rtx
1909
expand_call (tree exp, rtx target, int ignore)
1910
{
1911
  /* Nonzero if we are currently expanding a call.  */
1912
  static int currently_expanding_call = 0;
1913
 
1914
  /* RTX for the function to be called.  */
1915
  rtx funexp;
1916
  /* Sequence of insns to perform a normal "call".  */
1917
  rtx normal_call_insns = NULL_RTX;
1918
  /* Sequence of insns to perform a tail "call".  */
1919
  rtx tail_call_insns = NULL_RTX;
1920
  /* Data type of the function.  */
1921
  tree funtype;
1922
  tree type_arg_types;
1923
  tree rettype;
1924
  /* Declaration of the function being called,
1925
     or 0 if the function is computed (not known by name).  */
1926
  tree fndecl = 0;
1927
  /* The type of the function being called.  */
1928
  tree fntype;
1929
  bool try_tail_call = CALL_EXPR_TAILCALL (exp);
1930
  int pass;
1931
 
1932
  /* Register in which non-BLKmode value will be returned,
1933
     or 0 if no value or if value is BLKmode.  */
1934
  rtx valreg;
1935
  /* Address where we should return a BLKmode value;
1936
 
1937
  rtx structure_value_addr = 0;
1938
  /* Nonzero if that address is being passed by treating it as
1939
     an extra, implicit first parameter.  Otherwise,
1940
     it is passed by being copied directly into struct_value_rtx.  */
1941
  int structure_value_addr_parm = 0;
1942
  /* Holds the value of implicit argument for the struct value.  */
1943
  tree structure_value_addr_value = NULL_TREE;
1944
  /* Size of aggregate value wanted, or zero if none wanted
1945
     or if we are using the non-reentrant PCC calling convention
1946
     or expecting the value in registers.  */
1947
  HOST_WIDE_INT struct_value_size = 0;
1948
  /* Nonzero if called function returns an aggregate in memory PCC style,
1949
     by returning the address of where to find it.  */
1950
  int pcc_struct_value = 0;
1951
  rtx struct_value = 0;
1952
 
1953
  /* Number of actual parameters in this call, including struct value addr.  */
1954
  int num_actuals;
1955
  /* Number of named args.  Args after this are anonymous ones
1956
     and they must all go on the stack.  */
1957
  int n_named_args;
1958
  /* Number of complex actual arguments that need to be split.  */
1959
  int num_complex_actuals = 0;
1960
 
1961
  /* Vector of information about each argument.
1962
     Arguments are numbered in the order they will be pushed,
1963
     not the order they are written.  */
1964
  struct arg_data *args;
1965
 
1966
  /* Total size in bytes of all the stack-parms scanned so far.  */
1967
  struct args_size args_size;
1968
  struct args_size adjusted_args_size;
1969
  /* Size of arguments before any adjustments (such as rounding).  */
1970
  int unadjusted_args_size;
1971
  /* Data on reg parms scanned so far.  */
1972
  CUMULATIVE_ARGS args_so_far;
1973
  /* Nonzero if a reg parm has been scanned.  */
1974
  int reg_parm_seen;
1975
  /* Nonzero if this is an indirect function call.  */
1976
 
1977
  /* Nonzero if we must avoid push-insns in the args for this call.
1978
     If stack space is allocated for register parameters, but not by the
1979
     caller, then it is preallocated in the fixed part of the stack frame.
1980
     So the entire argument block must then be preallocated (i.e., we
1981
     ignore PUSH_ROUNDING in that case).  */
1982
 
1983
  int must_preallocate = !PUSH_ARGS;
1984
 
1985
  /* Size of the stack reserved for parameter registers.  */
1986
  int reg_parm_stack_space = 0;
1987
 
1988
  /* Address of space preallocated for stack parms
1989
     (on machines that lack push insns), or 0 if space not preallocated.  */
1990
  rtx argblock = 0;
1991
 
1992
  /* Mask of ECF_ flags.  */
1993
  int flags = 0;
1994
#ifdef REG_PARM_STACK_SPACE
1995
  /* Define the boundary of the register parm stack space that needs to be
1996
     saved, if any.  */
1997
  int low_to_save, high_to_save;
1998
  rtx save_area = 0;             /* Place that it is saved */
1999
#endif
2000
 
2001
  int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
2002
  char *initial_stack_usage_map = stack_usage_map;
2003
  char *stack_usage_map_buf = NULL;
2004
 
2005
  int old_stack_allocated;
2006
 
2007
  /* State variables to track stack modifications.  */
2008
  rtx old_stack_level = 0;
2009
  int old_stack_arg_under_construction = 0;
2010
  int old_pending_adj = 0;
2011
  int old_inhibit_defer_pop = inhibit_defer_pop;
2012
 
2013
  /* Some stack pointer alterations we make are performed via
2014
     allocate_dynamic_stack_space. This modifies the stack_pointer_delta,
2015
     which we then also need to save/restore along the way.  */
2016
  int old_stack_pointer_delta = 0;
2017
 
2018
  rtx call_fusage;
2019
  tree addr = CALL_EXPR_FN (exp);
2020
  int i;
2021
  /* The alignment of the stack, in bits.  */
2022
  unsigned HOST_WIDE_INT preferred_stack_boundary;
2023
  /* The alignment of the stack, in bytes.  */
2024
  unsigned HOST_WIDE_INT preferred_unit_stack_boundary;
2025
  /* The static chain value to use for this call.  */
2026
  rtx static_chain_value;
2027
  /* See if this is "nothrow" function call.  */
2028
  if (TREE_NOTHROW (exp))
2029
    flags |= ECF_NOTHROW;
2030
 
2031
  /* See if we can find a DECL-node for the actual function, and get the
2032
     function attributes (flags) from the function decl or type node.  */
2033
  fndecl = get_callee_fndecl (exp);
2034
  if (fndecl)
2035
    {
2036
      fntype = TREE_TYPE (fndecl);
2037
      flags |= flags_from_decl_or_type (fndecl);
2038
    }
2039
  else
2040
    {
2041
      fntype = TREE_TYPE (TREE_TYPE (addr));
2042
      flags |= flags_from_decl_or_type (fntype);
2043
    }
2044
  rettype = TREE_TYPE (exp);
2045
 
2046
  struct_value = targetm.calls.struct_value_rtx (fntype, 0);
2047
 
2048
  /* Warn if this value is an aggregate type,
2049
     regardless of which calling convention we are using for it.  */
2050
  if (AGGREGATE_TYPE_P (rettype))
2051
    warning (OPT_Waggregate_return, "function call has aggregate value");
2052
 
2053
  /* If the result of a non looping pure or const function call is
2054
     ignored (or void), and none of its arguments are volatile, we can
2055
     avoid expanding the call and just evaluate the arguments for
2056
     side-effects.  */
2057
  if ((flags & (ECF_CONST | ECF_PURE))
2058
      && (!(flags & ECF_LOOPING_CONST_OR_PURE))
2059
      && (ignore || target == const0_rtx
2060
          || TYPE_MODE (rettype) == VOIDmode))
2061
    {
2062
      bool volatilep = false;
2063
      tree arg;
2064
      call_expr_arg_iterator iter;
2065
 
2066
      FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
2067
        if (TREE_THIS_VOLATILE (arg))
2068
          {
2069
            volatilep = true;
2070
            break;
2071
          }
2072
 
2073
      if (! volatilep)
2074
        {
2075
          FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
2076
            expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
2077
          return const0_rtx;
2078
        }
2079
    }
2080
 
2081
#ifdef REG_PARM_STACK_SPACE
2082
  reg_parm_stack_space = REG_PARM_STACK_SPACE (!fndecl ? fntype : fndecl);
2083
#endif
2084
 
2085
  if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))
2086
      && reg_parm_stack_space > 0 && PUSH_ARGS)
2087
    must_preallocate = 1;
2088
 
2089
  /* Set up a place to return a structure.  */
2090
 
2091
  /* Cater to broken compilers.  */
2092
  if (aggregate_value_p (exp, (!fndecl ? fntype : fndecl)))
2093
    {
2094
      /* This call returns a big structure.  */
2095
      flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
2096
 
2097
#ifdef PCC_STATIC_STRUCT_RETURN
2098
      {
2099
        pcc_struct_value = 1;
2100
      }
2101
#else /* not PCC_STATIC_STRUCT_RETURN */
2102
      {
2103
        struct_value_size = int_size_in_bytes (rettype);
2104
 
2105
        if (target && MEM_P (target) && CALL_EXPR_RETURN_SLOT_OPT (exp))
2106
          structure_value_addr = XEXP (target, 0);
2107
        else
2108
          {
2109
            /* For variable-sized objects, we must be called with a target
2110
               specified.  If we were to allocate space on the stack here,
2111
               we would have no way of knowing when to free it.  */
2112
            rtx d = assign_temp (rettype, 0, 1, 1);
2113
 
2114
            mark_temp_addr_taken (d);
2115
            structure_value_addr = XEXP (d, 0);
2116
            target = 0;
2117
          }
2118
      }
2119
#endif /* not PCC_STATIC_STRUCT_RETURN */
2120
    }
2121
 
2122
  /* Figure out the amount to which the stack should be aligned.  */
2123
  preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
2124
  if (fndecl)
2125
    {
2126
      struct cgraph_rtl_info *i = cgraph_rtl_info (fndecl);
2127
      /* Without automatic stack alignment, we can't increase preferred
2128
         stack boundary.  With automatic stack alignment, it is
2129
         unnecessary since unless we can guarantee that all callers will
2130
         align the outgoing stack properly, callee has to align its
2131
         stack anyway.  */
2132
      if (i
2133
          && i->preferred_incoming_stack_boundary
2134
          && i->preferred_incoming_stack_boundary < preferred_stack_boundary)
2135
        preferred_stack_boundary = i->preferred_incoming_stack_boundary;
2136
    }
2137
 
2138
  /* Operand 0 is a pointer-to-function; get the type of the function.  */
2139
  funtype = TREE_TYPE (addr);
2140
  gcc_assert (POINTER_TYPE_P (funtype));
2141
  funtype = TREE_TYPE (funtype);
2142
 
2143
  /* Count whether there are actual complex arguments that need to be split
2144
     into their real and imaginary parts.  Munge the type_arg_types
2145
     appropriately here as well.  */
2146
  if (targetm.calls.split_complex_arg)
2147
    {
2148
      call_expr_arg_iterator iter;
2149
      tree arg;
2150
      FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
2151
        {
2152
          tree type = TREE_TYPE (arg);
2153
          if (type && TREE_CODE (type) == COMPLEX_TYPE
2154
              && targetm.calls.split_complex_arg (type))
2155
            num_complex_actuals++;
2156
        }
2157
      type_arg_types = split_complex_types (TYPE_ARG_TYPES (funtype));
2158
    }
2159
  else
2160
    type_arg_types = TYPE_ARG_TYPES (funtype);
2161
 
2162
  if (flags & ECF_MAY_BE_ALLOCA)
2163
    cfun->calls_alloca = 1;
2164
 
2165
  /* If struct_value_rtx is 0, it means pass the address
2166
     as if it were an extra parameter.  Put the argument expression
2167
     in structure_value_addr_value.  */
2168
  if (structure_value_addr && struct_value == 0)
2169
    {
2170
      /* If structure_value_addr is a REG other than
2171
         virtual_outgoing_args_rtx, we can use always use it.  If it
2172
         is not a REG, we must always copy it into a register.
2173
         If it is virtual_outgoing_args_rtx, we must copy it to another
2174
         register in some cases.  */
2175
      rtx temp = (!REG_P (structure_value_addr)
2176
                  || (ACCUMULATE_OUTGOING_ARGS
2177
                      && stack_arg_under_construction
2178
                      && structure_value_addr == virtual_outgoing_args_rtx)
2179
                  ? copy_addr_to_reg (convert_memory_address
2180
                                      (Pmode, structure_value_addr))
2181
                  : structure_value_addr);
2182
 
2183
      structure_value_addr_value =
2184
        make_tree (build_pointer_type (TREE_TYPE (funtype)), temp);
2185
      structure_value_addr_parm = 1;
2186
    }
2187
 
2188
  /* Count the arguments and set NUM_ACTUALS.  */
2189
  num_actuals =
2190
    call_expr_nargs (exp) + num_complex_actuals + structure_value_addr_parm;
2191
 
2192
  /* Compute number of named args.
2193
     First, do a raw count of the args for INIT_CUMULATIVE_ARGS.  */
2194
 
2195
  if (type_arg_types != 0)
2196
    n_named_args
2197
      = (list_length (type_arg_types)
2198
         /* Count the struct value address, if it is passed as a parm.  */
2199
         + structure_value_addr_parm);
2200
  else
2201
    /* If we know nothing, treat all args as named.  */
2202
    n_named_args = num_actuals;
2203
 
2204
  /* Start updating where the next arg would go.
2205
 
2206
     On some machines (such as the PA) indirect calls have a different
2207
     calling convention than normal calls.  The fourth argument in
2208
     INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
2209
     or not.  */
2210
  INIT_CUMULATIVE_ARGS (args_so_far, funtype, NULL_RTX, fndecl, n_named_args);
2211
 
2212
  /* Now possibly adjust the number of named args.
2213
     Normally, don't include the last named arg if anonymous args follow.
2214
     We do include the last named arg if
2215
     targetm.calls.strict_argument_naming() returns nonzero.
2216
     (If no anonymous args follow, the result of list_length is actually
2217
     one too large.  This is harmless.)
2218
 
2219
     If targetm.calls.pretend_outgoing_varargs_named() returns
2220
     nonzero, and targetm.calls.strict_argument_naming() returns zero,
2221
     this machine will be able to place unnamed args that were passed
2222
     in registers into the stack.  So treat all args as named.  This
2223
     allows the insns emitting for a specific argument list to be
2224
     independent of the function declaration.
2225
 
2226
     If targetm.calls.pretend_outgoing_varargs_named() returns zero,
2227
     we do not have any reliable way to pass unnamed args in
2228
     registers, so we must force them into memory.  */
2229
 
2230
  if (type_arg_types != 0
2231
      && targetm.calls.strict_argument_naming (&args_so_far))
2232
    ;
2233
  else if (type_arg_types != 0
2234
           && ! targetm.calls.pretend_outgoing_varargs_named (&args_so_far))
2235
    /* Don't include the last named arg.  */
2236
    --n_named_args;
2237
  else
2238
    /* Treat all args as named.  */
2239
    n_named_args = num_actuals;
2240
 
2241
  /* Make a vector to hold all the information about each arg.  */
2242
  args = XALLOCAVEC (struct arg_data, num_actuals);
2243
  memset (args, 0, num_actuals * sizeof (struct arg_data));
2244
 
2245
  /* Build up entries in the ARGS array, compute the size of the
2246
     arguments into ARGS_SIZE, etc.  */
2247
  initialize_argument_information (num_actuals, args, &args_size,
2248
                                   n_named_args, exp,
2249
                                   structure_value_addr_value, fndecl, fntype,
2250
                                   &args_so_far, reg_parm_stack_space,
2251
                                   &old_stack_level, &old_pending_adj,
2252
                                   &must_preallocate, &flags,
2253
                                   &try_tail_call, CALL_FROM_THUNK_P (exp));
2254
 
2255
  if (args_size.var)
2256
    must_preallocate = 1;
2257
 
2258
  /* Now make final decision about preallocating stack space.  */
2259
  must_preallocate = finalize_must_preallocate (must_preallocate,
2260
                                                num_actuals, args,
2261
                                                &args_size);
2262
 
2263
  /* If the structure value address will reference the stack pointer, we
2264
     must stabilize it.  We don't need to do this if we know that we are
2265
     not going to adjust the stack pointer in processing this call.  */
2266
 
2267
  if (structure_value_addr
2268
      && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
2269
          || reg_mentioned_p (virtual_outgoing_args_rtx,
2270
                              structure_value_addr))
2271
      && (args_size.var
2272
          || (!ACCUMULATE_OUTGOING_ARGS && args_size.constant)))
2273
    structure_value_addr = copy_to_reg (structure_value_addr);
2274
 
2275
  /* Tail calls can make things harder to debug, and we've traditionally
2276
     pushed these optimizations into -O2.  Don't try if we're already
2277
     expanding a call, as that means we're an argument.  Don't try if
2278
     there's cleanups, as we know there's code to follow the call.  */
2279
 
2280
  if (currently_expanding_call++ != 0
2281
      || !flag_optimize_sibling_calls
2282
      || args_size.var
2283
      || dbg_cnt (tail_call) == false)
2284
    try_tail_call = 0;
2285
 
2286
  /*  Rest of purposes for tail call optimizations to fail.  */
2287
  if (
2288
#ifdef HAVE_sibcall_epilogue
2289
      !HAVE_sibcall_epilogue
2290
#else
2291
      1
2292
#endif
2293
      || !try_tail_call
2294
      /* Doing sibling call optimization needs some work, since
2295
         structure_value_addr can be allocated on the stack.
2296
         It does not seem worth the effort since few optimizable
2297
         sibling calls will return a structure.  */
2298
      || structure_value_addr != NULL_RTX
2299
#ifdef REG_PARM_STACK_SPACE
2300
      /* If outgoing reg parm stack space changes, we can not do sibcall.  */
2301
      || (OUTGOING_REG_PARM_STACK_SPACE (funtype)
2302
          != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl)))
2303
      || (reg_parm_stack_space != REG_PARM_STACK_SPACE (fndecl))
2304
#endif
2305
      /* Check whether the target is able to optimize the call
2306
         into a sibcall.  */
2307
      || !targetm.function_ok_for_sibcall (fndecl, exp)
2308
      /* Functions that do not return exactly once may not be sibcall
2309
         optimized.  */
2310
      || (flags & (ECF_RETURNS_TWICE | ECF_NORETURN))
2311
      || TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr)))
2312
      /* If the called function is nested in the current one, it might access
2313
         some of the caller's arguments, but could clobber them beforehand if
2314
         the argument areas are shared.  */
2315
      || (fndecl && decl_function_context (fndecl) == current_function_decl)
2316
      /* If this function requires more stack slots than the current
2317
         function, we cannot change it into a sibling call.
2318
         crtl->args.pretend_args_size is not part of the
2319
         stack allocated by our caller.  */
2320
      || args_size.constant > (crtl->args.size
2321
                               - crtl->args.pretend_args_size)
2322
      /* If the callee pops its own arguments, then it must pop exactly
2323
         the same number of arguments as the current function.  */
2324
      || (RETURN_POPS_ARGS (fndecl, funtype, args_size.constant)
2325
          != RETURN_POPS_ARGS (current_function_decl,
2326
                               TREE_TYPE (current_function_decl),
2327
                               crtl->args.size))
2328
      || !lang_hooks.decls.ok_for_sibcall (fndecl))
2329
    try_tail_call = 0;
2330
 
2331
  /* Check if caller and callee disagree in promotion of function
2332
     return value.  */
2333
  if (try_tail_call)
2334
    {
2335
      enum machine_mode caller_mode, caller_promoted_mode;
2336
      enum machine_mode callee_mode, callee_promoted_mode;
2337
      int caller_unsignedp, callee_unsignedp;
2338
      tree caller_res = DECL_RESULT (current_function_decl);
2339
 
2340
      caller_unsignedp = TYPE_UNSIGNED (TREE_TYPE (caller_res));
2341
      caller_mode = DECL_MODE (caller_res);
2342
      callee_unsignedp = TYPE_UNSIGNED (TREE_TYPE (funtype));
2343
      callee_mode = TYPE_MODE (TREE_TYPE (funtype));
2344
      caller_promoted_mode
2345
        = promote_function_mode (TREE_TYPE (caller_res), caller_mode,
2346
                                 &caller_unsignedp,
2347
                                 TREE_TYPE (current_function_decl), 1);
2348
      callee_promoted_mode
2349
        = promote_function_mode (TREE_TYPE (funtype), callee_mode,
2350
                                 &callee_unsignedp,
2351
                                 funtype, 1);
2352
      if (caller_mode != VOIDmode
2353
          && (caller_promoted_mode != callee_promoted_mode
2354
              || ((caller_mode != caller_promoted_mode
2355
                   || callee_mode != callee_promoted_mode)
2356
                  && (caller_unsignedp != callee_unsignedp
2357
                      || GET_MODE_BITSIZE (caller_mode)
2358
                         < GET_MODE_BITSIZE (callee_mode)))))
2359
        try_tail_call = 0;
2360
    }
2361
 
2362
  /* Ensure current function's preferred stack boundary is at least
2363
     what we need.  Stack alignment may also increase preferred stack
2364
     boundary.  */
2365
  if (crtl->preferred_stack_boundary < preferred_stack_boundary)
2366
    crtl->preferred_stack_boundary = preferred_stack_boundary;
2367
  else
2368
    preferred_stack_boundary = crtl->preferred_stack_boundary;
2369
 
2370
  preferred_unit_stack_boundary = preferred_stack_boundary / BITS_PER_UNIT;
2371
 
2372
  /* We want to make two insn chains; one for a sibling call, the other
2373
     for a normal call.  We will select one of the two chains after
2374
     initial RTL generation is complete.  */
2375
  for (pass = try_tail_call ? 0 : 1; pass < 2; pass++)
2376
    {
2377
      int sibcall_failure = 0;
2378
      /* We want to emit any pending stack adjustments before the tail
2379
         recursion "call".  That way we know any adjustment after the tail
2380
         recursion call can be ignored if we indeed use the tail
2381
         call expansion.  */
2382
      int save_pending_stack_adjust = 0;
2383
      int save_stack_pointer_delta = 0;
2384
      rtx insns;
2385
      rtx before_call, next_arg_reg, after_args;
2386
 
2387
      if (pass == 0)
2388
        {
2389
          /* State variables we need to save and restore between
2390
             iterations.  */
2391
          save_pending_stack_adjust = pending_stack_adjust;
2392
          save_stack_pointer_delta = stack_pointer_delta;
2393
        }
2394
      if (pass)
2395
        flags &= ~ECF_SIBCALL;
2396
      else
2397
        flags |= ECF_SIBCALL;
2398
 
2399
      /* Other state variables that we must reinitialize each time
2400
         through the loop (that are not initialized by the loop itself).  */
2401
      argblock = 0;
2402
      call_fusage = 0;
2403
 
2404
      /* Start a new sequence for the normal call case.
2405
 
2406
         From this point on, if the sibling call fails, we want to set
2407
         sibcall_failure instead of continuing the loop.  */
2408
      start_sequence ();
2409
 
2410
      /* Don't let pending stack adjusts add up to too much.
2411
         Also, do all pending adjustments now if there is any chance
2412
         this might be a call to alloca or if we are expanding a sibling
2413
         call sequence.
2414
         Also do the adjustments before a throwing call, otherwise
2415
         exception handling can fail; PR 19225. */
2416
      if (pending_stack_adjust >= 32
2417
          || (pending_stack_adjust > 0
2418
              && (flags & ECF_MAY_BE_ALLOCA))
2419
          || (pending_stack_adjust > 0
2420
              && flag_exceptions && !(flags & ECF_NOTHROW))
2421
          || pass == 0)
2422
        do_pending_stack_adjust ();
2423
 
2424
      /* Precompute any arguments as needed.  */
2425
      if (pass)
2426
        precompute_arguments (num_actuals, args);
2427
 
2428
      /* Now we are about to start emitting insns that can be deleted
2429
         if a libcall is deleted.  */
2430
      if (pass && (flags & ECF_MALLOC))
2431
        start_sequence ();
2432
 
2433
      if (pass == 0 && crtl->stack_protect_guard)
2434
        stack_protect_epilogue ();
2435
 
2436
      adjusted_args_size = args_size;
2437
      /* Compute the actual size of the argument block required.  The variable
2438
         and constant sizes must be combined, the size may have to be rounded,
2439
         and there may be a minimum required size.  When generating a sibcall
2440
         pattern, do not round up, since we'll be re-using whatever space our
2441
         caller provided.  */
2442
      unadjusted_args_size
2443
        = compute_argument_block_size (reg_parm_stack_space,
2444
                                       &adjusted_args_size,
2445
                                       fndecl, fntype,
2446
                                       (pass == 0 ? 0
2447
                                        : preferred_stack_boundary));
2448
 
2449
      old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
2450
 
2451
      /* The argument block when performing a sibling call is the
2452
         incoming argument block.  */
2453
      if (pass == 0)
2454
        {
2455
          argblock = crtl->args.internal_arg_pointer;
2456
          argblock
2457
#ifdef STACK_GROWS_DOWNWARD
2458
            = plus_constant (argblock, crtl->args.pretend_args_size);
2459
#else
2460
            = plus_constant (argblock, -crtl->args.pretend_args_size);
2461
#endif
2462
          stored_args_map = sbitmap_alloc (args_size.constant);
2463
          sbitmap_zero (stored_args_map);
2464
        }
2465
 
2466
      /* If we have no actual push instructions, or shouldn't use them,
2467
         make space for all args right now.  */
2468
      else if (adjusted_args_size.var != 0)
2469
        {
2470
          if (old_stack_level == 0)
2471
            {
2472
              emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
2473
              old_stack_pointer_delta = stack_pointer_delta;
2474
              old_pending_adj = pending_stack_adjust;
2475
              pending_stack_adjust = 0;
2476
              /* stack_arg_under_construction says whether a stack arg is
2477
                 being constructed at the old stack level.  Pushing the stack
2478
                 gets a clean outgoing argument block.  */
2479
              old_stack_arg_under_construction = stack_arg_under_construction;
2480
              stack_arg_under_construction = 0;
2481
            }
2482
          argblock = push_block (ARGS_SIZE_RTX (adjusted_args_size), 0, 0);
2483
        }
2484
      else
2485
        {
2486
          /* Note that we must go through the motions of allocating an argument
2487
             block even if the size is zero because we may be storing args
2488
             in the area reserved for register arguments, which may be part of
2489
             the stack frame.  */
2490
 
2491
          int needed = adjusted_args_size.constant;
2492
 
2493
          /* Store the maximum argument space used.  It will be pushed by
2494
             the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
2495
             checking).  */
2496
 
2497
          if (needed > crtl->outgoing_args_size)
2498
            crtl->outgoing_args_size = needed;
2499
 
2500
          if (must_preallocate)
2501
            {
2502
              if (ACCUMULATE_OUTGOING_ARGS)
2503
                {
2504
                  /* Since the stack pointer will never be pushed, it is
2505
                     possible for the evaluation of a parm to clobber
2506
                     something we have already written to the stack.
2507
                     Since most function calls on RISC machines do not use
2508
                     the stack, this is uncommon, but must work correctly.
2509
 
2510
                     Therefore, we save any area of the stack that was already
2511
                     written and that we are using.  Here we set up to do this
2512
                     by making a new stack usage map from the old one.  The
2513
                     actual save will be done by store_one_arg.
2514
 
2515
                     Another approach might be to try to reorder the argument
2516
                     evaluations to avoid this conflicting stack usage.  */
2517
 
2518
                  /* Since we will be writing into the entire argument area,
2519
                     the map must be allocated for its entire size, not just
2520
                     the part that is the responsibility of the caller.  */
2521
                  if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
2522
                    needed += reg_parm_stack_space;
2523
 
2524
#ifdef ARGS_GROW_DOWNWARD
2525
                  highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2526
                                                     needed + 1);
2527
#else
2528
                  highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2529
                                                     needed);
2530
#endif
2531
                  if (stack_usage_map_buf)
2532
                    free (stack_usage_map_buf);
2533
                  stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
2534
                  stack_usage_map = stack_usage_map_buf;
2535
 
2536
                  if (initial_highest_arg_in_use)
2537
                    memcpy (stack_usage_map, initial_stack_usage_map,
2538
                            initial_highest_arg_in_use);
2539
 
2540
                  if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
2541
                    memset (&stack_usage_map[initial_highest_arg_in_use], 0,
2542
                           (highest_outgoing_arg_in_use
2543
                            - initial_highest_arg_in_use));
2544
                  needed = 0;
2545
 
2546
                  /* The address of the outgoing argument list must not be
2547
                     copied to a register here, because argblock would be left
2548
                     pointing to the wrong place after the call to
2549
                     allocate_dynamic_stack_space below.  */
2550
 
2551
                  argblock = virtual_outgoing_args_rtx;
2552
                }
2553
              else
2554
                {
2555
                  if (inhibit_defer_pop == 0)
2556
                    {
2557
                      /* Try to reuse some or all of the pending_stack_adjust
2558
                         to get this space.  */
2559
                      needed
2560
                        = (combine_pending_stack_adjustment_and_call
2561
                           (unadjusted_args_size,
2562
                            &adjusted_args_size,
2563
                            preferred_unit_stack_boundary));
2564
 
2565
                      /* combine_pending_stack_adjustment_and_call computes
2566
                         an adjustment before the arguments are allocated.
2567
                         Account for them and see whether or not the stack
2568
                         needs to go up or down.  */
2569
                      needed = unadjusted_args_size - needed;
2570
 
2571
                      if (needed < 0)
2572
                        {
2573
                          /* We're releasing stack space.  */
2574
                          /* ??? We can avoid any adjustment at all if we're
2575
                             already aligned.  FIXME.  */
2576
                          pending_stack_adjust = -needed;
2577
                          do_pending_stack_adjust ();
2578
                          needed = 0;
2579
                        }
2580
                      else
2581
                        /* We need to allocate space.  We'll do that in
2582
                           push_block below.  */
2583
                        pending_stack_adjust = 0;
2584
                    }
2585
 
2586
                  /* Special case this because overhead of `push_block' in
2587
                     this case is non-trivial.  */
2588
                  if (needed == 0)
2589
                    argblock = virtual_outgoing_args_rtx;
2590
                  else
2591
                    {
2592
                      argblock = push_block (GEN_INT (needed), 0, 0);
2593
#ifdef ARGS_GROW_DOWNWARD
2594
                      argblock = plus_constant (argblock, needed);
2595
#endif
2596
                    }
2597
 
2598
                  /* We only really need to call `copy_to_reg' in the case
2599
                     where push insns are going to be used to pass ARGBLOCK
2600
                     to a function call in ARGS.  In that case, the stack
2601
                     pointer changes value from the allocation point to the
2602
                     call point, and hence the value of
2603
                     VIRTUAL_OUTGOING_ARGS_RTX changes as well.  But might
2604
                     as well always do it.  */
2605
                  argblock = copy_to_reg (argblock);
2606
                }
2607
            }
2608
        }
2609
 
2610
      if (ACCUMULATE_OUTGOING_ARGS)
2611
        {
2612
          /* The save/restore code in store_one_arg handles all
2613
             cases except one: a constructor call (including a C
2614
             function returning a BLKmode struct) to initialize
2615
             an argument.  */
2616
          if (stack_arg_under_construction)
2617
            {
2618
              rtx push_size
2619
                = GEN_INT (adjusted_args_size.constant
2620
                           + (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype
2621
                                                                      : TREE_TYPE (fndecl))) ? 0
2622
                              : reg_parm_stack_space));
2623
              if (old_stack_level == 0)
2624
                {
2625
                  emit_stack_save (SAVE_BLOCK, &old_stack_level,
2626
                                   NULL_RTX);
2627
                  old_stack_pointer_delta = stack_pointer_delta;
2628
                  old_pending_adj = pending_stack_adjust;
2629
                  pending_stack_adjust = 0;
2630
                  /* stack_arg_under_construction says whether a stack
2631
                     arg is being constructed at the old stack level.
2632
                     Pushing the stack gets a clean outgoing argument
2633
                     block.  */
2634
                  old_stack_arg_under_construction
2635
                    = stack_arg_under_construction;
2636
                  stack_arg_under_construction = 0;
2637
                  /* Make a new map for the new argument list.  */
2638
                  if (stack_usage_map_buf)
2639
                    free (stack_usage_map_buf);
2640
                  stack_usage_map_buf = XCNEWVEC (char, highest_outgoing_arg_in_use);
2641
                  stack_usage_map = stack_usage_map_buf;
2642
                  highest_outgoing_arg_in_use = 0;
2643
                }
2644
              allocate_dynamic_stack_space (push_size, NULL_RTX,
2645
                                            BITS_PER_UNIT);
2646
            }
2647
 
2648
          /* If argument evaluation might modify the stack pointer,
2649
             copy the address of the argument list to a register.  */
2650
          for (i = 0; i < num_actuals; i++)
2651
            if (args[i].pass_on_stack)
2652
              {
2653
                argblock = copy_addr_to_reg (argblock);
2654
                break;
2655
              }
2656
        }
2657
 
2658
      compute_argument_addresses (args, argblock, num_actuals);
2659
 
2660
      /* If we push args individually in reverse order, perform stack alignment
2661
         before the first push (the last arg).  */
2662
      if (PUSH_ARGS_REVERSED && argblock == 0
2663
          && adjusted_args_size.constant != unadjusted_args_size)
2664
        {
2665
          /* When the stack adjustment is pending, we get better code
2666
             by combining the adjustments.  */
2667
          if (pending_stack_adjust
2668
              && ! inhibit_defer_pop)
2669
            {
2670
              pending_stack_adjust
2671
                = (combine_pending_stack_adjustment_and_call
2672
                   (unadjusted_args_size,
2673
                    &adjusted_args_size,
2674
                    preferred_unit_stack_boundary));
2675
              do_pending_stack_adjust ();
2676
            }
2677
          else if (argblock == 0)
2678
            anti_adjust_stack (GEN_INT (adjusted_args_size.constant
2679
                                        - unadjusted_args_size));
2680
        }
2681
      /* Now that the stack is properly aligned, pops can't safely
2682
         be deferred during the evaluation of the arguments.  */
2683
      NO_DEFER_POP;
2684
 
2685
      funexp = rtx_for_function_call (fndecl, addr);
2686
 
2687
      /* Figure out the register where the value, if any, will come back.  */
2688
      valreg = 0;
2689
      if (TYPE_MODE (rettype) != VOIDmode
2690
          && ! structure_value_addr)
2691
        {
2692
          if (pcc_struct_value)
2693
            valreg = hard_function_value (build_pointer_type (rettype),
2694
                                          fndecl, NULL, (pass == 0));
2695
          else
2696
            valreg = hard_function_value (rettype, fndecl, fntype,
2697
                                          (pass == 0));
2698
 
2699
          /* If VALREG is a PARALLEL whose first member has a zero
2700
             offset, use that.  This is for targets such as m68k that
2701
             return the same value in multiple places.  */
2702
          if (GET_CODE (valreg) == PARALLEL)
2703
            {
2704
              rtx elem = XVECEXP (valreg, 0, 0);
2705
              rtx where = XEXP (elem, 0);
2706
              rtx offset = XEXP (elem, 1);
2707
              if (offset == const0_rtx
2708
                  && GET_MODE (where) == GET_MODE (valreg))
2709
                valreg = where;
2710
            }
2711
        }
2712
 
2713
      /* Precompute all register parameters.  It isn't safe to compute anything
2714
         once we have started filling any specific hard regs.  */
2715
      precompute_register_parameters (num_actuals, args, &reg_parm_seen);
2716
 
2717
      if (CALL_EXPR_STATIC_CHAIN (exp))
2718
        static_chain_value = expand_normal (CALL_EXPR_STATIC_CHAIN (exp));
2719
      else
2720
        static_chain_value = 0;
2721
 
2722
#ifdef REG_PARM_STACK_SPACE
2723
      /* Save the fixed argument area if it's part of the caller's frame and
2724
         is clobbered by argument setup for this call.  */
2725
      if (ACCUMULATE_OUTGOING_ARGS && pass)
2726
        save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
2727
                                              &low_to_save, &high_to_save);
2728
#endif
2729
 
2730
      /* Now store (and compute if necessary) all non-register parms.
2731
         These come before register parms, since they can require block-moves,
2732
         which could clobber the registers used for register parms.
2733
         Parms which have partial registers are not stored here,
2734
         but we do preallocate space here if they want that.  */
2735
 
2736
      for (i = 0; i < num_actuals; i++)
2737
        {
2738
          if (args[i].reg == 0 || args[i].pass_on_stack)
2739
            {
2740
              rtx before_arg = get_last_insn ();
2741
 
2742
              if (store_one_arg (&args[i], argblock, flags,
2743
                                 adjusted_args_size.var != 0,
2744
                                 reg_parm_stack_space)
2745
                  || (pass == 0
2746
                      && check_sibcall_argument_overlap (before_arg,
2747
                                                         &args[i], 1)))
2748
                sibcall_failure = 1;
2749
              }
2750
 
2751
          if (((flags & ECF_CONST)
2752
               || ((flags & ECF_PURE) && ACCUMULATE_OUTGOING_ARGS))
2753
              && args[i].stack)
2754
            call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
2755
                                             gen_rtx_USE (VOIDmode,
2756
                                                          args[i].stack),
2757
                                             call_fusage);
2758
        }
2759
 
2760
      /* If we have a parm that is passed in registers but not in memory
2761
         and whose alignment does not permit a direct copy into registers,
2762
         make a group of pseudos that correspond to each register that we
2763
         will later fill.  */
2764
      if (STRICT_ALIGNMENT)
2765
        store_unaligned_arguments_into_pseudos (args, num_actuals);
2766
 
2767
      /* Now store any partially-in-registers parm.
2768
         This is the last place a block-move can happen.  */
2769
      if (reg_parm_seen)
2770
        for (i = 0; i < num_actuals; i++)
2771
          if (args[i].partial != 0 && ! args[i].pass_on_stack)
2772
            {
2773
              rtx before_arg = get_last_insn ();
2774
 
2775
              if (store_one_arg (&args[i], argblock, flags,
2776
                                 adjusted_args_size.var != 0,
2777
                                 reg_parm_stack_space)
2778
                  || (pass == 0
2779
                      && check_sibcall_argument_overlap (before_arg,
2780
                                                         &args[i], 1)))
2781
                sibcall_failure = 1;
2782
            }
2783
 
2784
      /* If we pushed args in forward order, perform stack alignment
2785
         after pushing the last arg.  */
2786
      if (!PUSH_ARGS_REVERSED && argblock == 0)
2787
        anti_adjust_stack (GEN_INT (adjusted_args_size.constant
2788
                                    - unadjusted_args_size));
2789
 
2790
      /* If register arguments require space on the stack and stack space
2791
         was not preallocated, allocate stack space here for arguments
2792
         passed in registers.  */
2793
      if (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))
2794
          && !ACCUMULATE_OUTGOING_ARGS
2795
          && must_preallocate == 0 && reg_parm_stack_space > 0)
2796
        anti_adjust_stack (GEN_INT (reg_parm_stack_space));
2797
 
2798
      /* Pass the function the address in which to return a
2799
         structure value.  */
2800
      if (pass != 0 && structure_value_addr && ! structure_value_addr_parm)
2801
        {
2802
          structure_value_addr
2803
            = convert_memory_address (Pmode, structure_value_addr);
2804
          emit_move_insn (struct_value,
2805
                          force_reg (Pmode,
2806
                                     force_operand (structure_value_addr,
2807
                                                    NULL_RTX)));
2808
 
2809
          if (REG_P (struct_value))
2810
            use_reg (&call_fusage, struct_value);
2811
        }
2812
 
2813
      after_args = get_last_insn ();
2814
      funexp = prepare_call_address (fndecl, funexp, static_chain_value,
2815
                                     &call_fusage, reg_parm_seen, pass == 0);
2816
 
2817
      load_register_parameters (args, num_actuals, &call_fusage, flags,
2818
                                pass == 0, &sibcall_failure);
2819
 
2820
      /* Save a pointer to the last insn before the call, so that we can
2821
         later safely search backwards to find the CALL_INSN.  */
2822
      before_call = get_last_insn ();
2823
 
2824
      /* Set up next argument register.  For sibling calls on machines
2825
         with register windows this should be the incoming register.  */
2826
#ifdef FUNCTION_INCOMING_ARG
2827
      if (pass == 0)
2828
        next_arg_reg = FUNCTION_INCOMING_ARG (args_so_far, VOIDmode,
2829
                                              void_type_node, 1);
2830
      else
2831
#endif
2832
        next_arg_reg = FUNCTION_ARG (args_so_far, VOIDmode,
2833
                                     void_type_node, 1);
2834
 
2835
      /* All arguments and registers used for the call must be set up by
2836
         now!  */
2837
 
2838
      /* Stack must be properly aligned now.  */
2839
      gcc_assert (!pass
2840
                  || !(stack_pointer_delta % preferred_unit_stack_boundary));
2841
 
2842
      /* Generate the actual call instruction.  */
2843
      emit_call_1 (funexp, exp, fndecl, funtype, unadjusted_args_size,
2844
                   adjusted_args_size.constant, struct_value_size,
2845
                   next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
2846
                   flags, & args_so_far);
2847
 
2848
      /* If the call setup or the call itself overlaps with anything
2849
         of the argument setup we probably clobbered our call address.
2850
         In that case we can't do sibcalls.  */
2851
      if (pass == 0
2852
          && check_sibcall_argument_overlap (after_args, 0, 0))
2853
        sibcall_failure = 1;
2854
 
2855
      /* If a non-BLKmode value is returned at the most significant end
2856
         of a register, shift the register right by the appropriate amount
2857
         and update VALREG accordingly.  BLKmode values are handled by the
2858
         group load/store machinery below.  */
2859
      if (!structure_value_addr
2860
          && !pcc_struct_value
2861
          && TYPE_MODE (rettype) != BLKmode
2862
          && targetm.calls.return_in_msb (rettype))
2863
        {
2864
          if (shift_return_value (TYPE_MODE (rettype), false, valreg))
2865
            sibcall_failure = 1;
2866
          valreg = gen_rtx_REG (TYPE_MODE (rettype), REGNO (valreg));
2867
        }
2868
 
2869
      if (pass && (flags & ECF_MALLOC))
2870
        {
2871
          rtx temp = gen_reg_rtx (GET_MODE (valreg));
2872
          rtx last, insns;
2873
 
2874
          /* The return value from a malloc-like function is a pointer.  */
2875
          if (TREE_CODE (rettype) == POINTER_TYPE)
2876
            mark_reg_pointer (temp, BIGGEST_ALIGNMENT);
2877
 
2878
          emit_move_insn (temp, valreg);
2879
 
2880
          /* The return value from a malloc-like function can not alias
2881
             anything else.  */
2882
          last = get_last_insn ();
2883
          add_reg_note (last, REG_NOALIAS, temp);
2884
 
2885
          /* Write out the sequence.  */
2886
          insns = get_insns ();
2887
          end_sequence ();
2888
          emit_insn (insns);
2889
          valreg = temp;
2890
        }
2891
 
2892
      /* For calls to `setjmp', etc., inform
2893
         function.c:setjmp_warnings that it should complain if
2894
         nonvolatile values are live.  For functions that cannot
2895
         return, inform flow that control does not fall through.  */
2896
 
2897
      if ((flags & ECF_NORETURN) || pass == 0)
2898
        {
2899
          /* The barrier must be emitted
2900
             immediately after the CALL_INSN.  Some ports emit more
2901
             than just a CALL_INSN above, so we must search for it here.  */
2902
 
2903
          rtx last = get_last_insn ();
2904
          while (!CALL_P (last))
2905
            {
2906
              last = PREV_INSN (last);
2907
              /* There was no CALL_INSN?  */
2908
              gcc_assert (last != before_call);
2909
            }
2910
 
2911
          emit_barrier_after (last);
2912
 
2913
          /* Stack adjustments after a noreturn call are dead code.
2914
             However when NO_DEFER_POP is in effect, we must preserve
2915
             stack_pointer_delta.  */
2916
          if (inhibit_defer_pop == 0)
2917
            {
2918
              stack_pointer_delta = old_stack_allocated;
2919
              pending_stack_adjust = 0;
2920
            }
2921
        }
2922
 
2923
      /* If value type not void, return an rtx for the value.  */
2924
 
2925
      if (TYPE_MODE (rettype) == VOIDmode
2926
          || ignore)
2927
        target = const0_rtx;
2928
      else if (structure_value_addr)
2929
        {
2930
          if (target == 0 || !MEM_P (target))
2931
            {
2932
              target
2933
                = gen_rtx_MEM (TYPE_MODE (rettype),
2934
                               memory_address (TYPE_MODE (rettype),
2935
                                               structure_value_addr));
2936
              set_mem_attributes (target, rettype, 1);
2937
            }
2938
        }
2939
      else if (pcc_struct_value)
2940
        {
2941
          /* This is the special C++ case where we need to
2942
             know what the true target was.  We take care to
2943
             never use this value more than once in one expression.  */
2944
          target = gen_rtx_MEM (TYPE_MODE (rettype),
2945
                                copy_to_reg (valreg));
2946
          set_mem_attributes (target, rettype, 1);
2947
        }
2948
      /* Handle calls that return values in multiple non-contiguous locations.
2949
         The Irix 6 ABI has examples of this.  */
2950
      else if (GET_CODE (valreg) == PARALLEL)
2951
        {
2952
          if (target == 0)
2953
            {
2954
              /* This will only be assigned once, so it can be readonly.  */
2955
              tree nt = build_qualified_type (rettype,
2956
                                              (TYPE_QUALS (rettype)
2957
                                               | TYPE_QUAL_CONST));
2958
 
2959
              target = assign_temp (nt, 0, 1, 1);
2960
            }
2961
 
2962
          if (! rtx_equal_p (target, valreg))
2963
            emit_group_store (target, valreg, rettype,
2964
                              int_size_in_bytes (rettype));
2965
 
2966
          /* We can not support sibling calls for this case.  */
2967
          sibcall_failure = 1;
2968
        }
2969
      else if (target
2970
               && GET_MODE (target) == TYPE_MODE (rettype)
2971
               && GET_MODE (target) == GET_MODE (valreg))
2972
        {
2973
          bool may_overlap = false;
2974
 
2975
          /* We have to copy a return value in a CLASS_LIKELY_SPILLED hard
2976
             reg to a plain register.  */
2977
          if (!REG_P (target) || HARD_REGISTER_P (target))
2978
            valreg = avoid_likely_spilled_reg (valreg);
2979
 
2980
          /* If TARGET is a MEM in the argument area, and we have
2981
             saved part of the argument area, then we can't store
2982
             directly into TARGET as it may get overwritten when we
2983
             restore the argument save area below.  Don't work too
2984
             hard though and simply force TARGET to a register if it
2985
             is a MEM; the optimizer is quite likely to sort it out.  */
2986
          if (ACCUMULATE_OUTGOING_ARGS && pass && MEM_P (target))
2987
            for (i = 0; i < num_actuals; i++)
2988
              if (args[i].save_area)
2989
                {
2990
                  may_overlap = true;
2991
                  break;
2992
                }
2993
 
2994
          if (may_overlap)
2995
            target = copy_to_reg (valreg);
2996
          else
2997
            {
2998
              /* TARGET and VALREG cannot be equal at this point
2999
                 because the latter would not have
3000
                 REG_FUNCTION_VALUE_P true, while the former would if
3001
                 it were referring to the same register.
3002
 
3003
                 If they refer to the same register, this move will be
3004
                 a no-op, except when function inlining is being
3005
                 done.  */
3006
              emit_move_insn (target, valreg);
3007
 
3008
              /* If we are setting a MEM, this code must be executed.
3009
                 Since it is emitted after the call insn, sibcall
3010
                 optimization cannot be performed in that case.  */
3011
              if (MEM_P (target))
3012
                sibcall_failure = 1;
3013
            }
3014
        }
3015
      else if (TYPE_MODE (rettype) == BLKmode)
3016
        {
3017
          rtx val = valreg;
3018
          if (GET_MODE (val) != BLKmode)
3019
            val = avoid_likely_spilled_reg (val);
3020
          target = copy_blkmode_from_reg (target, val, rettype);
3021
 
3022
          /* We can not support sibling calls for this case.  */
3023
          sibcall_failure = 1;
3024
        }
3025
      else
3026
        target = copy_to_reg (avoid_likely_spilled_reg (valreg));
3027
 
3028
      /* If we promoted this return value, make the proper SUBREG.
3029
         TARGET might be const0_rtx here, so be careful.  */
3030
      if (REG_P (target)
3031
          && TYPE_MODE (rettype) != BLKmode
3032
          && GET_MODE (target) != TYPE_MODE (rettype))
3033
        {
3034
          tree type = rettype;
3035
          int unsignedp = TYPE_UNSIGNED (type);
3036
          int offset = 0;
3037
          enum machine_mode pmode;
3038
 
3039
          /* Ensure we promote as expected, and get the new unsignedness.  */
3040
          pmode = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
3041
                                         funtype, 1);
3042
          gcc_assert (GET_MODE (target) == pmode);
3043
 
3044
          if ((WORDS_BIG_ENDIAN || BYTES_BIG_ENDIAN)
3045
              && (GET_MODE_SIZE (GET_MODE (target))
3046
                  > GET_MODE_SIZE (TYPE_MODE (type))))
3047
            {
3048
              offset = GET_MODE_SIZE (GET_MODE (target))
3049
                - GET_MODE_SIZE (TYPE_MODE (type));
3050
              if (! BYTES_BIG_ENDIAN)
3051
                offset = (offset / UNITS_PER_WORD) * UNITS_PER_WORD;
3052
              else if (! WORDS_BIG_ENDIAN)
3053
                offset %= UNITS_PER_WORD;
3054
            }
3055
 
3056
          target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
3057
          SUBREG_PROMOTED_VAR_P (target) = 1;
3058
          SUBREG_PROMOTED_UNSIGNED_SET (target, unsignedp);
3059
        }
3060
 
3061
      /* If size of args is variable or this was a constructor call for a stack
3062
         argument, restore saved stack-pointer value.  */
3063
 
3064
      if (old_stack_level)
3065
        {
3066
          emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
3067
          stack_pointer_delta = old_stack_pointer_delta;
3068
          pending_stack_adjust = old_pending_adj;
3069
          old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
3070
          stack_arg_under_construction = old_stack_arg_under_construction;
3071
          highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3072
          stack_usage_map = initial_stack_usage_map;
3073
          sibcall_failure = 1;
3074
        }
3075
      else if (ACCUMULATE_OUTGOING_ARGS && pass)
3076
        {
3077
#ifdef REG_PARM_STACK_SPACE
3078
          if (save_area)
3079
            restore_fixed_argument_area (save_area, argblock,
3080
                                         high_to_save, low_to_save);
3081
#endif
3082
 
3083
          /* If we saved any argument areas, restore them.  */
3084
          for (i = 0; i < num_actuals; i++)
3085
            if (args[i].save_area)
3086
              {
3087
                enum machine_mode save_mode = GET_MODE (args[i].save_area);
3088
                rtx stack_area
3089
                  = gen_rtx_MEM (save_mode,
3090
                                 memory_address (save_mode,
3091
                                                 XEXP (args[i].stack_slot, 0)));
3092
 
3093
                if (save_mode != BLKmode)
3094
                  emit_move_insn (stack_area, args[i].save_area);
3095
                else
3096
                  emit_block_move (stack_area, args[i].save_area,
3097
                                   GEN_INT (args[i].locate.size.constant),
3098
                                   BLOCK_OP_CALL_PARM);
3099
              }
3100
 
3101
          highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3102
          stack_usage_map = initial_stack_usage_map;
3103
        }
3104
 
3105
      /* If this was alloca, record the new stack level for nonlocal gotos.
3106
         Check for the handler slots since we might not have a save area
3107
         for non-local gotos.  */
3108
 
3109
      if ((flags & ECF_MAY_BE_ALLOCA) && cfun->nonlocal_goto_save_area != 0)
3110
        update_nonlocal_goto_save_area ();
3111
 
3112
      /* Free up storage we no longer need.  */
3113
      for (i = 0; i < num_actuals; ++i)
3114
        if (args[i].aligned_regs)
3115
          free (args[i].aligned_regs);
3116
 
3117
      insns = get_insns ();
3118
      end_sequence ();
3119
 
3120
      if (pass == 0)
3121
        {
3122
          tail_call_insns = insns;
3123
 
3124
          /* Restore the pending stack adjustment now that we have
3125
             finished generating the sibling call sequence.  */
3126
 
3127
          pending_stack_adjust = save_pending_stack_adjust;
3128
          stack_pointer_delta = save_stack_pointer_delta;
3129
 
3130
          /* Prepare arg structure for next iteration.  */
3131
          for (i = 0; i < num_actuals; i++)
3132
            {
3133
              args[i].value = 0;
3134
              args[i].aligned_regs = 0;
3135
              args[i].stack = 0;
3136
            }
3137
 
3138
          sbitmap_free (stored_args_map);
3139
        }
3140
      else
3141
        {
3142
          normal_call_insns = insns;
3143
 
3144
          /* Verify that we've deallocated all the stack we used.  */
3145
          gcc_assert ((flags & ECF_NORETURN)
3146
                      || (old_stack_allocated
3147
                          == stack_pointer_delta - pending_stack_adjust));
3148
        }
3149
 
3150
      /* If something prevents making this a sibling call,
3151
         zero out the sequence.  */
3152
      if (sibcall_failure)
3153
        tail_call_insns = NULL_RTX;
3154
      else
3155
        break;
3156
    }
3157
 
3158
  /* If tail call production succeeded, we need to remove REG_EQUIV notes on
3159
     arguments too, as argument area is now clobbered by the call.  */
3160
  if (tail_call_insns)
3161
    {
3162
      emit_insn (tail_call_insns);
3163
      crtl->tail_call_emit = true;
3164
    }
3165
  else
3166
    emit_insn (normal_call_insns);
3167
 
3168
  currently_expanding_call--;
3169
 
3170
  if (stack_usage_map_buf)
3171
    free (stack_usage_map_buf);
3172
 
3173
  return target;
3174
}
3175
 
3176
/* A sibling call sequence invalidates any REG_EQUIV notes made for
3177
   this function's incoming arguments.
3178
 
3179
   At the start of RTL generation we know the only REG_EQUIV notes
3180
   in the rtl chain are those for incoming arguments, so we can look
3181
   for REG_EQUIV notes between the start of the function and the
3182
   NOTE_INSN_FUNCTION_BEG.
3183
 
3184
   This is (slight) overkill.  We could keep track of the highest
3185
   argument we clobber and be more selective in removing notes, but it
3186
   does not seem to be worth the effort.  */
3187
 
3188
void
3189
fixup_tail_calls (void)
3190
{
3191
  rtx insn;
3192
 
3193
  for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3194
    {
3195
      rtx note;
3196
 
3197
      /* There are never REG_EQUIV notes for the incoming arguments
3198
         after the NOTE_INSN_FUNCTION_BEG note, so stop if we see it.  */
3199
      if (NOTE_P (insn)
3200
          && NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG)
3201
        break;
3202
 
3203
      note = find_reg_note (insn, REG_EQUIV, 0);
3204
      if (note)
3205
        remove_note (insn, note);
3206
      note = find_reg_note (insn, REG_EQUIV, 0);
3207
      gcc_assert (!note);
3208
    }
3209
}
3210
 
3211
/* Traverse a list of TYPES and expand all complex types into their
3212
   components.  */
3213
static tree
3214
split_complex_types (tree types)
3215
{
3216
  tree p;
3217
 
3218
  /* Before allocating memory, check for the common case of no complex.  */
3219
  for (p = types; p; p = TREE_CHAIN (p))
3220
    {
3221
      tree type = TREE_VALUE (p);
3222
      if (TREE_CODE (type) == COMPLEX_TYPE
3223
          && targetm.calls.split_complex_arg (type))
3224
        goto found;
3225
    }
3226
  return types;
3227
 
3228
 found:
3229
  types = copy_list (types);
3230
 
3231
  for (p = types; p; p = TREE_CHAIN (p))
3232
    {
3233
      tree complex_type = TREE_VALUE (p);
3234
 
3235
      if (TREE_CODE (complex_type) == COMPLEX_TYPE
3236
          && targetm.calls.split_complex_arg (complex_type))
3237
        {
3238
          tree next, imag;
3239
 
3240
          /* Rewrite complex type with component type.  */
3241
          TREE_VALUE (p) = TREE_TYPE (complex_type);
3242
          next = TREE_CHAIN (p);
3243
 
3244
          /* Add another component type for the imaginary part.  */
3245
          imag = build_tree_list (NULL_TREE, TREE_VALUE (p));
3246
          TREE_CHAIN (p) = imag;
3247
          TREE_CHAIN (imag) = next;
3248
 
3249
          /* Skip the newly created node.  */
3250
          p = TREE_CHAIN (p);
3251
        }
3252
    }
3253
 
3254
  return types;
3255
}
3256
 
3257
/* Output a library call to function FUN (a SYMBOL_REF rtx).
3258
   The RETVAL parameter specifies whether return value needs to be saved, other
3259
   parameters are documented in the emit_library_call function below.  */
3260
 
3261
static rtx
3262
emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
3263
                           enum libcall_type fn_type,
3264
                           enum machine_mode outmode, int nargs, va_list p)
3265
{
3266
  /* Total size in bytes of all the stack-parms scanned so far.  */
3267
  struct args_size args_size;
3268
  /* Size of arguments before any adjustments (such as rounding).  */
3269
  struct args_size original_args_size;
3270
  int argnum;
3271
  rtx fun;
3272
  /* Todo, choose the correct decl type of orgfun. Sadly this information
3273
     isn't present here, so we default to native calling abi here.  */
3274
  tree fndecl ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */
3275
  tree fntype ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */
3276
  int inc;
3277
  int count;
3278
  rtx argblock = 0;
3279
  CUMULATIVE_ARGS args_so_far;
3280
  struct arg
3281
  {
3282
    rtx value;
3283
    enum machine_mode mode;
3284
    rtx reg;
3285
    int partial;
3286
    struct locate_and_pad_arg_data locate;
3287
    rtx save_area;
3288
  };
3289
  struct arg *argvec;
3290
  int old_inhibit_defer_pop = inhibit_defer_pop;
3291
  rtx call_fusage = 0;
3292
  rtx mem_value = 0;
3293
  rtx valreg;
3294
  int pcc_struct_value = 0;
3295
  int struct_value_size = 0;
3296
  int flags;
3297
  int reg_parm_stack_space = 0;
3298
  int needed;
3299
  rtx before_call;
3300
  tree tfom;                    /* type_for_mode (outmode, 0) */
3301
 
3302
#ifdef REG_PARM_STACK_SPACE
3303
  /* Define the boundary of the register parm stack space that needs to be
3304
     save, if any.  */
3305
  int low_to_save = 0, high_to_save = 0;
3306
  rtx save_area = 0;            /* Place that it is saved.  */
3307
#endif
3308
 
3309
  /* Size of the stack reserved for parameter registers.  */
3310
  int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
3311
  char *initial_stack_usage_map = stack_usage_map;
3312
  char *stack_usage_map_buf = NULL;
3313
 
3314
  rtx struct_value = targetm.calls.struct_value_rtx (0, 0);
3315
 
3316
#ifdef REG_PARM_STACK_SPACE
3317
  reg_parm_stack_space = REG_PARM_STACK_SPACE ((tree) 0);
3318
#endif
3319
 
3320
  /* By default, library functions can not throw.  */
3321
  flags = ECF_NOTHROW;
3322
 
3323
  switch (fn_type)
3324
    {
3325
    case LCT_NORMAL:
3326
      break;
3327
    case LCT_CONST:
3328
      flags |= ECF_CONST;
3329
      break;
3330
    case LCT_PURE:
3331
      flags |= ECF_PURE;
3332
      break;
3333
    case LCT_NORETURN:
3334
      flags |= ECF_NORETURN;
3335
      break;
3336
    case LCT_THROW:
3337
      flags = ECF_NORETURN;
3338
      break;
3339
    case LCT_RETURNS_TWICE:
3340
      flags = ECF_RETURNS_TWICE;
3341
      break;
3342
    }
3343
  fun = orgfun;
3344
 
3345
  /* Ensure current function's preferred stack boundary is at least
3346
     what we need.  */
3347
  if (crtl->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY)
3348
    crtl->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
3349
 
3350
  /* If this kind of value comes back in memory,
3351
     decide where in memory it should come back.  */
3352
  if (outmode != VOIDmode)
3353
    {
3354
      tfom = lang_hooks.types.type_for_mode (outmode, 0);
3355
      if (aggregate_value_p (tfom, 0))
3356
        {
3357
#ifdef PCC_STATIC_STRUCT_RETURN
3358
          rtx pointer_reg
3359
            = hard_function_value (build_pointer_type (tfom), 0, 0, 0);
3360
          mem_value = gen_rtx_MEM (outmode, pointer_reg);
3361
          pcc_struct_value = 1;
3362
          if (value == 0)
3363
            value = gen_reg_rtx (outmode);
3364
#else /* not PCC_STATIC_STRUCT_RETURN */
3365
          struct_value_size = GET_MODE_SIZE (outmode);
3366
          if (value != 0 && MEM_P (value))
3367
            mem_value = value;
3368
          else
3369
            mem_value = assign_temp (tfom, 0, 1, 1);
3370
#endif
3371
          /* This call returns a big structure.  */
3372
          flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
3373
        }
3374
    }
3375
  else
3376
    tfom = void_type_node;
3377
 
3378
  /* ??? Unfinished: must pass the memory address as an argument.  */
3379
 
3380
  /* Copy all the libcall-arguments out of the varargs data
3381
     and into a vector ARGVEC.
3382
 
3383
     Compute how to pass each argument.  We only support a very small subset
3384
     of the full argument passing conventions to limit complexity here since
3385
     library functions shouldn't have many args.  */
3386
 
3387
  argvec = XALLOCAVEC (struct arg, nargs + 1);
3388
  memset (argvec, 0, (nargs + 1) * sizeof (struct arg));
3389
 
3390
#ifdef INIT_CUMULATIVE_LIBCALL_ARGS
3391
  INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far, outmode, fun);
3392
#else
3393
  INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun, 0, nargs);
3394
#endif
3395
 
3396
  args_size.constant = 0;
3397
  args_size.var = 0;
3398
 
3399
  count = 0;
3400
 
3401
  push_temp_slots ();
3402
 
3403
  /* If there's a structure value address to be passed,
3404
     either pass it in the special place, or pass it as an extra argument.  */
3405
  if (mem_value && struct_value == 0 && ! pcc_struct_value)
3406
    {
3407
      rtx addr = XEXP (mem_value, 0);
3408
 
3409
      nargs++;
3410
 
3411
      /* Make sure it is a reasonable operand for a move or push insn.  */
3412
      if (!REG_P (addr) && !MEM_P (addr)
3413
          && ! (CONSTANT_P (addr) && LEGITIMATE_CONSTANT_P (addr)))
3414
        addr = force_operand (addr, NULL_RTX);
3415
 
3416
      argvec[count].value = addr;
3417
      argvec[count].mode = Pmode;
3418
      argvec[count].partial = 0;
3419
 
3420
      argvec[count].reg = FUNCTION_ARG (args_so_far, Pmode, NULL_TREE, 1);
3421
      gcc_assert (targetm.calls.arg_partial_bytes (&args_so_far, Pmode,
3422
                                                   NULL_TREE, 1) == 0);
3423
 
3424
      locate_and_pad_parm (Pmode, NULL_TREE,
3425
#ifdef STACK_PARMS_IN_REG_PARM_AREA
3426
                           1,
3427
#else
3428
                           argvec[count].reg != 0,
3429
#endif
3430
                           0, NULL_TREE, &args_size, &argvec[count].locate);
3431
 
3432
      if (argvec[count].reg == 0 || argvec[count].partial != 0
3433
          || reg_parm_stack_space > 0)
3434
        args_size.constant += argvec[count].locate.size.constant;
3435
 
3436
      FUNCTION_ARG_ADVANCE (args_so_far, Pmode, (tree) 0, 1);
3437
 
3438
      count++;
3439
    }
3440
 
3441
  for (; count < nargs; count++)
3442
    {
3443
      rtx val = va_arg (p, rtx);
3444
      enum machine_mode mode = (enum machine_mode) va_arg (p, int);
3445
 
3446
      /* We cannot convert the arg value to the mode the library wants here;
3447
         must do it earlier where we know the signedness of the arg.  */
3448
      gcc_assert (mode != BLKmode
3449
                  && (GET_MODE (val) == mode || GET_MODE (val) == VOIDmode));
3450
 
3451
      /* Make sure it is a reasonable operand for a move or push insn.  */
3452
      if (!REG_P (val) && !MEM_P (val)
3453
          && ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val)))
3454
        val = force_operand (val, NULL_RTX);
3455
 
3456
      if (pass_by_reference (&args_so_far, mode, NULL_TREE, 1))
3457
        {
3458
          rtx slot;
3459
          int must_copy
3460
            = !reference_callee_copied (&args_so_far, mode, NULL_TREE, 1);
3461
 
3462
          /* If this was a CONST function, it is now PURE since it now
3463
             reads memory.  */
3464
          if (flags & ECF_CONST)
3465
            {
3466
              flags &= ~ECF_CONST;
3467
              flags |= ECF_PURE;
3468
            }
3469
 
3470
          if (MEM_P (val) && !must_copy)
3471
            slot = val;
3472
          else
3473
            {
3474
              slot = assign_temp (lang_hooks.types.type_for_mode (mode, 0),
3475
                                  0, 1, 1);
3476
              emit_move_insn (slot, val);
3477
            }
3478
 
3479
          call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
3480
                                           gen_rtx_USE (VOIDmode, slot),
3481
                                           call_fusage);
3482
          if (must_copy)
3483
            call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
3484
                                             gen_rtx_CLOBBER (VOIDmode,
3485
                                                              slot),
3486
                                             call_fusage);
3487
 
3488
          mode = Pmode;
3489
          val = force_operand (XEXP (slot, 0), NULL_RTX);
3490
        }
3491
 
3492
      argvec[count].value = val;
3493
      argvec[count].mode = mode;
3494
 
3495
      argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
3496
 
3497
      argvec[count].partial
3498
        = targetm.calls.arg_partial_bytes (&args_so_far, mode, NULL_TREE, 1);
3499
 
3500
      locate_and_pad_parm (mode, NULL_TREE,
3501
#ifdef STACK_PARMS_IN_REG_PARM_AREA
3502
                           1,
3503
#else
3504
                           argvec[count].reg != 0,
3505
#endif
3506
                           argvec[count].partial,
3507
                           NULL_TREE, &args_size, &argvec[count].locate);
3508
 
3509
      gcc_assert (!argvec[count].locate.size.var);
3510
 
3511
      if (argvec[count].reg == 0 || argvec[count].partial != 0
3512
          || reg_parm_stack_space > 0)
3513
        args_size.constant += argvec[count].locate.size.constant;
3514
 
3515
      FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree) 0, 1);
3516
    }
3517
 
3518
  /* If this machine requires an external definition for library
3519
     functions, write one out.  */
3520
  assemble_external_libcall (fun);
3521
 
3522
  original_args_size = args_size;
3523
  args_size.constant = (((args_size.constant
3524
                          + stack_pointer_delta
3525
                          + STACK_BYTES - 1)
3526
                          / STACK_BYTES
3527
                          * STACK_BYTES)
3528
                         - stack_pointer_delta);
3529
 
3530
  args_size.constant = MAX (args_size.constant,
3531
                            reg_parm_stack_space);
3532
 
3533
  if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
3534
    args_size.constant -= reg_parm_stack_space;
3535
 
3536
  if (args_size.constant > crtl->outgoing_args_size)
3537
    crtl->outgoing_args_size = args_size.constant;
3538
 
3539
  if (ACCUMULATE_OUTGOING_ARGS)
3540
    {
3541
      /* Since the stack pointer will never be pushed, it is possible for
3542
         the evaluation of a parm to clobber something we have already
3543
         written to the stack.  Since most function calls on RISC machines
3544
         do not use the stack, this is uncommon, but must work correctly.
3545
 
3546
         Therefore, we save any area of the stack that was already written
3547
         and that we are using.  Here we set up to do this by making a new
3548
         stack usage map from the old one.
3549
 
3550
         Another approach might be to try to reorder the argument
3551
         evaluations to avoid this conflicting stack usage.  */
3552
 
3553
      needed = args_size.constant;
3554
 
3555
      /* Since we will be writing into the entire argument area, the
3556
         map must be allocated for its entire size, not just the part that
3557
         is the responsibility of the caller.  */
3558
      if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
3559
        needed += reg_parm_stack_space;
3560
 
3561
#ifdef ARGS_GROW_DOWNWARD
3562
      highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
3563
                                         needed + 1);
3564
#else
3565
      highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
3566
                                         needed);
3567
#endif
3568
      stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
3569
      stack_usage_map = stack_usage_map_buf;
3570
 
3571
      if (initial_highest_arg_in_use)
3572
        memcpy (stack_usage_map, initial_stack_usage_map,
3573
                initial_highest_arg_in_use);
3574
 
3575
      if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
3576
        memset (&stack_usage_map[initial_highest_arg_in_use], 0,
3577
               highest_outgoing_arg_in_use - initial_highest_arg_in_use);
3578
      needed = 0;
3579
 
3580
      /* We must be careful to use virtual regs before they're instantiated,
3581
         and real regs afterwards.  Loop optimization, for example, can create
3582
         new libcalls after we've instantiated the virtual regs, and if we
3583
         use virtuals anyway, they won't match the rtl patterns.  */
3584
 
3585
      if (virtuals_instantiated)
3586
        argblock = plus_constant (stack_pointer_rtx, STACK_POINTER_OFFSET);
3587
      else
3588
        argblock = virtual_outgoing_args_rtx;
3589
    }
3590
  else
3591
    {
3592
      if (!PUSH_ARGS)
3593
        argblock = push_block (GEN_INT (args_size.constant), 0, 0);
3594
    }
3595
 
3596
  /* If we push args individually in reverse order, perform stack alignment
3597
     before the first push (the last arg).  */
3598
  if (argblock == 0 && PUSH_ARGS_REVERSED)
3599
    anti_adjust_stack (GEN_INT (args_size.constant
3600
                                - original_args_size.constant));
3601
 
3602
  if (PUSH_ARGS_REVERSED)
3603
    {
3604
      inc = -1;
3605
      argnum = nargs - 1;
3606
    }
3607
  else
3608
    {
3609
      inc = 1;
3610
      argnum = 0;
3611
    }
3612
 
3613
#ifdef REG_PARM_STACK_SPACE
3614
  if (ACCUMULATE_OUTGOING_ARGS)
3615
    {
3616
      /* The argument list is the property of the called routine and it
3617
         may clobber it.  If the fixed area has been used for previous
3618
         parameters, we must save and restore it.  */
3619
      save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
3620
                                            &low_to_save, &high_to_save);
3621
    }
3622
#endif
3623
 
3624
  /* Push the args that need to be pushed.  */
3625
 
3626
  /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3627
     are to be pushed.  */
3628
  for (count = 0; count < nargs; count++, argnum += inc)
3629
    {
3630
      enum machine_mode mode = argvec[argnum].mode;
3631
      rtx val = argvec[argnum].value;
3632
      rtx reg = argvec[argnum].reg;
3633
      int partial = argvec[argnum].partial;
3634
      unsigned int parm_align = argvec[argnum].locate.boundary;
3635
      int lower_bound = 0, upper_bound = 0, i;
3636
 
3637
      if (! (reg != 0 && partial == 0))
3638
        {
3639
          if (ACCUMULATE_OUTGOING_ARGS)
3640
            {
3641
              /* If this is being stored into a pre-allocated, fixed-size,
3642
                 stack area, save any previous data at that location.  */
3643
 
3644
#ifdef ARGS_GROW_DOWNWARD
3645
              /* stack_slot is negative, but we want to index stack_usage_map
3646
                 with positive values.  */
3647
              upper_bound = -argvec[argnum].locate.slot_offset.constant + 1;
3648
              lower_bound = upper_bound - argvec[argnum].locate.size.constant;
3649
#else
3650
              lower_bound = argvec[argnum].locate.slot_offset.constant;
3651
              upper_bound = lower_bound + argvec[argnum].locate.size.constant;
3652
#endif
3653
 
3654
              i = lower_bound;
3655
              /* Don't worry about things in the fixed argument area;
3656
                 it has already been saved.  */
3657
              if (i < reg_parm_stack_space)
3658
                i = reg_parm_stack_space;
3659
              while (i < upper_bound && stack_usage_map[i] == 0)
3660
                i++;
3661
 
3662
              if (i < upper_bound)
3663
                {
3664
                  /* We need to make a save area.  */
3665
                  unsigned int size
3666
                    = argvec[argnum].locate.size.constant * BITS_PER_UNIT;
3667
                  enum machine_mode save_mode
3668
                    = mode_for_size (size, MODE_INT, 1);
3669
                  rtx adr
3670
                    = plus_constant (argblock,
3671
                                     argvec[argnum].locate.offset.constant);
3672
                  rtx stack_area
3673
                    = gen_rtx_MEM (save_mode, memory_address (save_mode, adr));
3674
 
3675
                  if (save_mode == BLKmode)
3676
                    {
3677
                      argvec[argnum].save_area
3678
                        = assign_stack_temp (BLKmode,
3679
                                             argvec[argnum].locate.size.constant,
3680
                                             0);
3681
 
3682
                      emit_block_move (validize_mem (argvec[argnum].save_area),
3683
                                       stack_area,
3684
                                       GEN_INT (argvec[argnum].locate.size.constant),
3685
                                       BLOCK_OP_CALL_PARM);
3686
                    }
3687
                  else
3688
                    {
3689
                      argvec[argnum].save_area = gen_reg_rtx (save_mode);
3690
 
3691
                      emit_move_insn (argvec[argnum].save_area, stack_area);
3692
                    }
3693
                }
3694
            }
3695
 
3696
          emit_push_insn (val, mode, NULL_TREE, NULL_RTX, parm_align,
3697
                          partial, reg, 0, argblock,
3698
                          GEN_INT (argvec[argnum].locate.offset.constant),
3699
                          reg_parm_stack_space,
3700
                          ARGS_SIZE_RTX (argvec[argnum].locate.alignment_pad));
3701
 
3702
          /* Now mark the segment we just used.  */
3703
          if (ACCUMULATE_OUTGOING_ARGS)
3704
            for (i = lower_bound; i < upper_bound; i++)
3705
              stack_usage_map[i] = 1;
3706
 
3707
          NO_DEFER_POP;
3708
 
3709
          if ((flags & ECF_CONST)
3710
              || ((flags & ECF_PURE) && ACCUMULATE_OUTGOING_ARGS))
3711
            {
3712
              rtx use;
3713
 
3714
              /* Indicate argument access so that alias.c knows that these
3715
                 values are live.  */
3716
              if (argblock)
3717
                use = plus_constant (argblock,
3718
                                     argvec[argnum].locate.offset.constant);
3719
              else
3720
                /* When arguments are pushed, trying to tell alias.c where
3721
                   exactly this argument is won't work, because the
3722
                   auto-increment causes confusion.  So we merely indicate
3723
                   that we access something with a known mode somewhere on
3724
                   the stack.  */
3725
                use = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3726
                                    gen_rtx_SCRATCH (Pmode));
3727
              use = gen_rtx_MEM (argvec[argnum].mode, use);
3728
              use = gen_rtx_USE (VOIDmode, use);
3729
              call_fusage = gen_rtx_EXPR_LIST (VOIDmode, use, call_fusage);
3730
            }
3731
        }
3732
    }
3733
 
3734
  /* If we pushed args in forward order, perform stack alignment
3735
     after pushing the last arg.  */
3736
  if (argblock == 0 && !PUSH_ARGS_REVERSED)
3737
    anti_adjust_stack (GEN_INT (args_size.constant
3738
                                - original_args_size.constant));
3739
 
3740
  if (PUSH_ARGS_REVERSED)
3741
    argnum = nargs - 1;
3742
  else
3743
    argnum = 0;
3744
 
3745
  fun = prepare_call_address (NULL, fun, NULL, &call_fusage, 0, 0);
3746
 
3747
  /* Now load any reg parms into their regs.  */
3748
 
3749
  /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3750
     are to be pushed.  */
3751
  for (count = 0; count < nargs; count++, argnum += inc)
3752
    {
3753
      enum machine_mode mode = argvec[argnum].mode;
3754
      rtx val = argvec[argnum].value;
3755
      rtx reg = argvec[argnum].reg;
3756
      int partial = argvec[argnum].partial;
3757
 
3758
      /* Handle calls that pass values in multiple non-contiguous
3759
         locations.  The PA64 has examples of this for library calls.  */
3760
      if (reg != 0 && GET_CODE (reg) == PARALLEL)
3761
        emit_group_load (reg, val, NULL_TREE, GET_MODE_SIZE (mode));
3762
      else if (reg != 0 && partial == 0)
3763
        emit_move_insn (reg, val);
3764
 
3765
      NO_DEFER_POP;
3766
    }
3767
 
3768
  /* Any regs containing parms remain in use through the call.  */
3769
  for (count = 0; count < nargs; count++)
3770
    {
3771
      rtx reg = argvec[count].reg;
3772
      if (reg != 0 && GET_CODE (reg) == PARALLEL)
3773
        use_group_regs (&call_fusage, reg);
3774
      else if (reg != 0)
3775
        {
3776
          int partial = argvec[count].partial;
3777
          if (partial)
3778
            {
3779
              int nregs;
3780
              gcc_assert (partial % UNITS_PER_WORD == 0);
3781
              nregs = partial / UNITS_PER_WORD;
3782
              use_regs (&call_fusage, REGNO (reg), nregs);
3783
            }
3784
          else
3785
            use_reg (&call_fusage, reg);
3786
        }
3787
    }
3788
 
3789
  /* Pass the function the address in which to return a structure value.  */
3790
  if (mem_value != 0 && struct_value != 0 && ! pcc_struct_value)
3791
    {
3792
      emit_move_insn (struct_value,
3793
                      force_reg (Pmode,
3794
                                 force_operand (XEXP (mem_value, 0),
3795
                                                NULL_RTX)));
3796
      if (REG_P (struct_value))
3797
        use_reg (&call_fusage, struct_value);
3798
    }
3799
 
3800
  /* Don't allow popping to be deferred, since then
3801
     cse'ing of library calls could delete a call and leave the pop.  */
3802
  NO_DEFER_POP;
3803
  valreg = (mem_value == 0 && outmode != VOIDmode
3804
            ? hard_libcall_value (outmode, orgfun) : NULL_RTX);
3805
 
3806
  /* Stack must be properly aligned now.  */
3807
  gcc_assert (!(stack_pointer_delta
3808
                & (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1)));
3809
 
3810
  before_call = get_last_insn ();
3811
 
3812
  /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
3813
     will set inhibit_defer_pop to that value.  */
3814
  /* The return type is needed to decide how many bytes the function pops.
3815
     Signedness plays no role in that, so for simplicity, we pretend it's
3816
     always signed.  We also assume that the list of arguments passed has
3817
     no impact, so we pretend it is unknown.  */
3818
 
3819
  emit_call_1 (fun, NULL,
3820
               get_identifier (XSTR (orgfun, 0)),
3821
               build_function_type (tfom, NULL_TREE),
3822
               original_args_size.constant, args_size.constant,
3823
               struct_value_size,
3824
               FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
3825
               valreg,
3826
               old_inhibit_defer_pop + 1, call_fusage, flags, & args_so_far);
3827
 
3828
  /* For calls to `setjmp', etc., inform function.c:setjmp_warnings
3829
     that it should complain if nonvolatile values are live.  For
3830
     functions that cannot return, inform flow that control does not
3831
     fall through.  */
3832
 
3833
  if (flags & ECF_NORETURN)
3834
    {
3835
      /* The barrier note must be emitted
3836
         immediately after the CALL_INSN.  Some ports emit more than
3837
         just a CALL_INSN above, so we must search for it here.  */
3838
 
3839
      rtx last = get_last_insn ();
3840
      while (!CALL_P (last))
3841
        {
3842
          last = PREV_INSN (last);
3843
          /* There was no CALL_INSN?  */
3844
          gcc_assert (last != before_call);
3845
        }
3846
 
3847
      emit_barrier_after (last);
3848
    }
3849
 
3850
  /* Now restore inhibit_defer_pop to its actual original value.  */
3851
  OK_DEFER_POP;
3852
 
3853
  pop_temp_slots ();
3854
 
3855
  /* Copy the value to the right place.  */
3856
  if (outmode != VOIDmode && retval)
3857
    {
3858
      if (mem_value)
3859
        {
3860
          if (value == 0)
3861
            value = mem_value;
3862
          if (value != mem_value)
3863
            emit_move_insn (value, mem_value);
3864
        }
3865
      else if (GET_CODE (valreg) == PARALLEL)
3866
        {
3867
          if (value == 0)
3868
            value = gen_reg_rtx (outmode);
3869
          emit_group_store (value, valreg, NULL_TREE, GET_MODE_SIZE (outmode));
3870
        }
3871
      else
3872
        {
3873
          /* Convert to the proper mode if a promotion has been active.  */
3874
          if (GET_MODE (valreg) != outmode)
3875
            {
3876
              int unsignedp = TYPE_UNSIGNED (tfom);
3877
 
3878
              gcc_assert (promote_function_mode (tfom, outmode, &unsignedp,
3879
                                                 fndecl ? TREE_TYPE (fndecl) : fntype, 1)
3880
                          == GET_MODE (valreg));
3881
              valreg = convert_modes (outmode, GET_MODE (valreg), valreg, 0);
3882
            }
3883
 
3884
          if (value != 0)
3885
            emit_move_insn (value, valreg);
3886
          else
3887
            value = valreg;
3888
        }
3889
    }
3890
 
3891
  if (ACCUMULATE_OUTGOING_ARGS)
3892
    {
3893
#ifdef REG_PARM_STACK_SPACE
3894
      if (save_area)
3895
        restore_fixed_argument_area (save_area, argblock,
3896
                                     high_to_save, low_to_save);
3897
#endif
3898
 
3899
      /* If we saved any argument areas, restore them.  */
3900
      for (count = 0; count < nargs; count++)
3901
        if (argvec[count].save_area)
3902
          {
3903
            enum machine_mode save_mode = GET_MODE (argvec[count].save_area);
3904
            rtx adr = plus_constant (argblock,
3905
                                     argvec[count].locate.offset.constant);
3906
            rtx stack_area = gen_rtx_MEM (save_mode,
3907
                                          memory_address (save_mode, adr));
3908
 
3909
            if (save_mode == BLKmode)
3910
              emit_block_move (stack_area,
3911
                               validize_mem (argvec[count].save_area),
3912
                               GEN_INT (argvec[count].locate.size.constant),
3913
                               BLOCK_OP_CALL_PARM);
3914
            else
3915
              emit_move_insn (stack_area, argvec[count].save_area);
3916
          }
3917
 
3918
      highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3919
      stack_usage_map = initial_stack_usage_map;
3920
    }
3921
 
3922
  if (stack_usage_map_buf)
3923
    free (stack_usage_map_buf);
3924
 
3925
  return value;
3926
 
3927
}
3928
 
3929
/* Output a library call to function FUN (a SYMBOL_REF rtx)
3930
   (emitting the queue unless NO_QUEUE is nonzero),
3931
   for a value of mode OUTMODE,
3932
   with NARGS different arguments, passed as alternating rtx values
3933
   and machine_modes to convert them to.
3934
 
3935
   FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for
3936
   `const' calls, LCT_PURE for `pure' calls, or other LCT_ value for
3937
   other types of library calls.  */
3938
 
3939
void
3940
emit_library_call (rtx orgfun, enum libcall_type fn_type,
3941
                   enum machine_mode outmode, int nargs, ...)
3942
{
3943
  va_list p;
3944
 
3945
  va_start (p, nargs);
3946
  emit_library_call_value_1 (0, orgfun, NULL_RTX, fn_type, outmode, nargs, p);
3947
  va_end (p);
3948
}
3949
 
3950
/* Like emit_library_call except that an extra argument, VALUE,
3951
   comes second and says where to store the result.
3952
   (If VALUE is zero, this function chooses a convenient way
3953
   to return the value.
3954
 
3955
   This function returns an rtx for where the value is to be found.
3956
   If VALUE is nonzero, VALUE is returned.  */
3957
 
3958
rtx
3959
emit_library_call_value (rtx orgfun, rtx value,
3960
                         enum libcall_type fn_type,
3961
                         enum machine_mode outmode, int nargs, ...)
3962
{
3963
  rtx result;
3964
  va_list p;
3965
 
3966
  va_start (p, nargs);
3967
  result = emit_library_call_value_1 (1, orgfun, value, fn_type, outmode,
3968
                                      nargs, p);
3969
  va_end (p);
3970
 
3971
  return result;
3972
}
3973
 
3974
/* Store a single argument for a function call
3975
   into the register or memory area where it must be passed.
3976
   *ARG describes the argument value and where to pass it.
3977
 
3978
   ARGBLOCK is the address of the stack-block for all the arguments,
3979
   or 0 on a machine where arguments are pushed individually.
3980
 
3981
   MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
3982
   so must be careful about how the stack is used.
3983
 
3984
   VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
3985
   argument stack.  This is used if ACCUMULATE_OUTGOING_ARGS to indicate
3986
   that we need not worry about saving and restoring the stack.
3987
 
3988
   FNDECL is the declaration of the function we are calling.
3989
 
3990
   Return nonzero if this arg should cause sibcall failure,
3991
   zero otherwise.  */
3992
 
3993
static int
3994
store_one_arg (struct arg_data *arg, rtx argblock, int flags,
3995
               int variable_size ATTRIBUTE_UNUSED, int reg_parm_stack_space)
3996
{
3997
  tree pval = arg->tree_value;
3998
  rtx reg = 0;
3999
  int partial = 0;
4000
  int used = 0;
4001
  int i, lower_bound = 0, upper_bound = 0;
4002
  int sibcall_failure = 0;
4003
 
4004
  if (TREE_CODE (pval) == ERROR_MARK)
4005
    return 1;
4006
 
4007
  /* Push a new temporary level for any temporaries we make for
4008
     this argument.  */
4009
  push_temp_slots ();
4010
 
4011
  if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL))
4012
    {
4013
      /* If this is being stored into a pre-allocated, fixed-size, stack area,
4014
         save any previous data at that location.  */
4015
      if (argblock && ! variable_size && arg->stack)
4016
        {
4017
#ifdef ARGS_GROW_DOWNWARD
4018
          /* stack_slot is negative, but we want to index stack_usage_map
4019
             with positive values.  */
4020
          if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
4021
            upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1;
4022
          else
4023
            upper_bound = 0;
4024
 
4025
          lower_bound = upper_bound - arg->locate.size.constant;
4026
#else
4027
          if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
4028
            lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1));
4029
          else
4030
            lower_bound = 0;
4031
 
4032
          upper_bound = lower_bound + arg->locate.size.constant;
4033
#endif
4034
 
4035
          i = lower_bound;
4036
          /* Don't worry about things in the fixed argument area;
4037
             it has already been saved.  */
4038
          if (i < reg_parm_stack_space)
4039
            i = reg_parm_stack_space;
4040
          while (i < upper_bound && stack_usage_map[i] == 0)
4041
            i++;
4042
 
4043
          if (i < upper_bound)
4044
            {
4045
              /* We need to make a save area.  */
4046
              unsigned int size = arg->locate.size.constant * BITS_PER_UNIT;
4047
              enum machine_mode save_mode = mode_for_size (size, MODE_INT, 1);
4048
              rtx adr = memory_address (save_mode, XEXP (arg->stack_slot, 0));
4049
              rtx stack_area = gen_rtx_MEM (save_mode, adr);
4050
 
4051
              if (save_mode == BLKmode)
4052
                {
4053
                  tree ot = TREE_TYPE (arg->tree_value);
4054
                  tree nt = build_qualified_type (ot, (TYPE_QUALS (ot)
4055
                                                       | TYPE_QUAL_CONST));
4056
 
4057
                  arg->save_area = assign_temp (nt, 0, 1, 1);
4058
                  preserve_temp_slots (arg->save_area);
4059
                  emit_block_move (validize_mem (arg->save_area), stack_area,
4060
                                   GEN_INT (arg->locate.size.constant),
4061
                                   BLOCK_OP_CALL_PARM);
4062
                }
4063
              else
4064
                {
4065
                  arg->save_area = gen_reg_rtx (save_mode);
4066
                  emit_move_insn (arg->save_area, stack_area);
4067
                }
4068
            }
4069
        }
4070
    }
4071
 
4072
  /* If this isn't going to be placed on both the stack and in registers,
4073
     set up the register and number of words.  */
4074
  if (! arg->pass_on_stack)
4075
    {
4076
      if (flags & ECF_SIBCALL)
4077
        reg = arg->tail_call_reg;
4078
      else
4079
        reg = arg->reg;
4080
      partial = arg->partial;
4081
    }
4082
 
4083
  /* Being passed entirely in a register.  We shouldn't be called in
4084
     this case.  */
4085
  gcc_assert (reg == 0 || partial != 0);
4086
 
4087
  /* If this arg needs special alignment, don't load the registers
4088
     here.  */
4089
  if (arg->n_aligned_regs != 0)
4090
    reg = 0;
4091
 
4092
  /* If this is being passed partially in a register, we can't evaluate
4093
     it directly into its stack slot.  Otherwise, we can.  */
4094
  if (arg->value == 0)
4095
    {
4096
      /* stack_arg_under_construction is nonzero if a function argument is
4097
         being evaluated directly into the outgoing argument list and
4098
         expand_call must take special action to preserve the argument list
4099
         if it is called recursively.
4100
 
4101
         For scalar function arguments stack_usage_map is sufficient to
4102
         determine which stack slots must be saved and restored.  Scalar
4103
         arguments in general have pass_on_stack == 0.
4104
 
4105
         If this argument is initialized by a function which takes the
4106
         address of the argument (a C++ constructor or a C function
4107
         returning a BLKmode structure), then stack_usage_map is
4108
         insufficient and expand_call must push the stack around the
4109
         function call.  Such arguments have pass_on_stack == 1.
4110
 
4111
         Note that it is always safe to set stack_arg_under_construction,
4112
         but this generates suboptimal code if set when not needed.  */
4113
 
4114
      if (arg->pass_on_stack)
4115
        stack_arg_under_construction++;
4116
 
4117
      arg->value = expand_expr (pval,
4118
                                (partial
4119
                                 || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
4120
                                ? NULL_RTX : arg->stack,
4121
                                VOIDmode, EXPAND_STACK_PARM);
4122
 
4123
      /* If we are promoting object (or for any other reason) the mode
4124
         doesn't agree, convert the mode.  */
4125
 
4126
      if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
4127
        arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
4128
                                    arg->value, arg->unsignedp);
4129
 
4130
      if (arg->pass_on_stack)
4131
        stack_arg_under_construction--;
4132
    }
4133
 
4134
  /* Check for overlap with already clobbered argument area.  */
4135
  if ((flags & ECF_SIBCALL)
4136
      && MEM_P (arg->value)
4137
      && mem_overlaps_already_clobbered_arg_p (XEXP (arg->value, 0),
4138
                                               arg->locate.size.constant))
4139
    sibcall_failure = 1;
4140
 
4141
  /* Don't allow anything left on stack from computation
4142
     of argument to alloca.  */
4143
  if (flags & ECF_MAY_BE_ALLOCA)
4144
    do_pending_stack_adjust ();
4145
 
4146
  if (arg->value == arg->stack)
4147
    /* If the value is already in the stack slot, we are done.  */
4148
    ;
4149
  else if (arg->mode != BLKmode)
4150
    {
4151
      int size;
4152
      unsigned int parm_align;
4153
 
4154
      /* Argument is a scalar, not entirely passed in registers.
4155
         (If part is passed in registers, arg->partial says how much
4156
         and emit_push_insn will take care of putting it there.)
4157
 
4158
         Push it, and if its size is less than the
4159
         amount of space allocated to it,
4160
         also bump stack pointer by the additional space.
4161
         Note that in C the default argument promotions
4162
         will prevent such mismatches.  */
4163
 
4164
      size = GET_MODE_SIZE (arg->mode);
4165
      /* Compute how much space the push instruction will push.
4166
         On many machines, pushing a byte will advance the stack
4167
         pointer by a halfword.  */
4168
#ifdef PUSH_ROUNDING
4169
      size = PUSH_ROUNDING (size);
4170
#endif
4171
      used = size;
4172
 
4173
      /* Compute how much space the argument should get:
4174
         round up to a multiple of the alignment for arguments.  */
4175
      if (none != FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)))
4176
        used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
4177
                 / (PARM_BOUNDARY / BITS_PER_UNIT))
4178
                * (PARM_BOUNDARY / BITS_PER_UNIT));
4179
 
4180
      /* Compute the alignment of the pushed argument.  */
4181
      parm_align = arg->locate.boundary;
4182
      if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward)
4183
        {
4184
          int pad = used - size;
4185
          if (pad)
4186
            {
4187
              unsigned int pad_align = (pad & -pad) * BITS_PER_UNIT;
4188
              parm_align = MIN (parm_align, pad_align);
4189
            }
4190
        }
4191
 
4192
      /* This isn't already where we want it on the stack, so put it there.
4193
         This can either be done with push or copy insns.  */
4194
      emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX,
4195
                      parm_align, partial, reg, used - size, argblock,
4196
                      ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
4197
                      ARGS_SIZE_RTX (arg->locate.alignment_pad));
4198
 
4199
      /* Unless this is a partially-in-register argument, the argument is now
4200
         in the stack.  */
4201
      if (partial == 0)
4202
        arg->value = arg->stack;
4203
    }
4204
  else
4205
    {
4206
      /* BLKmode, at least partly to be pushed.  */
4207
 
4208
      unsigned int parm_align;
4209
      int excess;
4210
      rtx size_rtx;
4211
 
4212
      /* Pushing a nonscalar.
4213
         If part is passed in registers, PARTIAL says how much
4214
         and emit_push_insn will take care of putting it there.  */
4215
 
4216
      /* Round its size up to a multiple
4217
         of the allocation unit for arguments.  */
4218
 
4219
      if (arg->locate.size.var != 0)
4220
        {
4221
          excess = 0;
4222
          size_rtx = ARGS_SIZE_RTX (arg->locate.size);
4223
        }
4224
      else
4225
        {
4226
          /* PUSH_ROUNDING has no effect on us, because emit_push_insn
4227
             for BLKmode is careful to avoid it.  */
4228
          excess = (arg->locate.size.constant
4229
                    - int_size_in_bytes (TREE_TYPE (pval))
4230
                    + partial);
4231
          size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)),
4232
                                  NULL_RTX, TYPE_MODE (sizetype),
4233
                                  EXPAND_NORMAL);
4234
        }
4235
 
4236
      parm_align = arg->locate.boundary;
4237
 
4238
      /* When an argument is padded down, the block is aligned to
4239
         PARM_BOUNDARY, but the actual argument isn't.  */
4240
      if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward)
4241
        {
4242
          if (arg->locate.size.var)
4243
            parm_align = BITS_PER_UNIT;
4244
          else if (excess)
4245
            {
4246
              unsigned int excess_align = (excess & -excess) * BITS_PER_UNIT;
4247
              parm_align = MIN (parm_align, excess_align);
4248
            }
4249
        }
4250
 
4251
      if ((flags & ECF_SIBCALL) && MEM_P (arg->value))
4252
        {
4253
          /* emit_push_insn might not work properly if arg->value and
4254
             argblock + arg->locate.offset areas overlap.  */
4255
          rtx x = arg->value;
4256
          int i = 0;
4257
 
4258
          if (XEXP (x, 0) == crtl->args.internal_arg_pointer
4259
              || (GET_CODE (XEXP (x, 0)) == PLUS
4260
                  && XEXP (XEXP (x, 0), 0) ==
4261
                     crtl->args.internal_arg_pointer
4262
                  && CONST_INT_P (XEXP (XEXP (x, 0), 1))))
4263
            {
4264
              if (XEXP (x, 0) != crtl->args.internal_arg_pointer)
4265
                i = INTVAL (XEXP (XEXP (x, 0), 1));
4266
 
4267
              /* expand_call should ensure this.  */
4268
              gcc_assert (!arg->locate.offset.var
4269
                          && arg->locate.size.var == 0
4270
                          && CONST_INT_P (size_rtx));
4271
 
4272
              if (arg->locate.offset.constant > i)
4273
                {
4274
                  if (arg->locate.offset.constant < i + INTVAL (size_rtx))
4275
                    sibcall_failure = 1;
4276
                }
4277
              else if (arg->locate.offset.constant < i)
4278
                {
4279
                  /* Use arg->locate.size.constant instead of size_rtx
4280
                     because we only care about the part of the argument
4281
                     on the stack.  */
4282
                  if (i < (arg->locate.offset.constant
4283
                           + arg->locate.size.constant))
4284
                    sibcall_failure = 1;
4285
                }
4286
              else
4287
                {
4288
                  /* Even though they appear to be at the same location,
4289
                     if part of the outgoing argument is in registers,
4290
                     they aren't really at the same location.  Check for
4291
                     this by making sure that the incoming size is the
4292
                     same as the outgoing size.  */
4293
                  if (arg->locate.size.constant != INTVAL (size_rtx))
4294
                    sibcall_failure = 1;
4295
                }
4296
            }
4297
        }
4298
 
4299
      emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
4300
                      parm_align, partial, reg, excess, argblock,
4301
                      ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
4302
                      ARGS_SIZE_RTX (arg->locate.alignment_pad));
4303
 
4304
      /* Unless this is a partially-in-register argument, the argument is now
4305
         in the stack.
4306
 
4307
         ??? Unlike the case above, in which we want the actual
4308
         address of the data, so that we can load it directly into a
4309
         register, here we want the address of the stack slot, so that
4310
         it's properly aligned for word-by-word copying or something
4311
         like that.  It's not clear that this is always correct.  */
4312
      if (partial == 0)
4313
        arg->value = arg->stack_slot;
4314
    }
4315
 
4316
  if (arg->reg && GET_CODE (arg->reg) == PARALLEL)
4317
    {
4318
      tree type = TREE_TYPE (arg->tree_value);
4319
      arg->parallel_value
4320
        = emit_group_load_into_temps (arg->reg, arg->value, type,
4321
                                      int_size_in_bytes (type));
4322
    }
4323
 
4324
  /* Mark all slots this store used.  */
4325
  if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL)
4326
      && argblock && ! variable_size && arg->stack)
4327
    for (i = lower_bound; i < upper_bound; i++)
4328
      stack_usage_map[i] = 1;
4329
 
4330
  /* Once we have pushed something, pops can't safely
4331
     be deferred during the rest of the arguments.  */
4332
  NO_DEFER_POP;
4333
 
4334
  /* Free any temporary slots made in processing this argument.  Show
4335
     that we might have taken the address of something and pushed that
4336
     as an operand.  */
4337
  preserve_temp_slots (NULL_RTX);
4338
  free_temp_slots ();
4339
  pop_temp_slots ();
4340
 
4341
  return sibcall_failure;
4342
}
4343
 
4344
/* Nonzero if we do not know how to pass TYPE solely in registers.  */
4345
 
4346
bool
4347
must_pass_in_stack_var_size (enum machine_mode mode ATTRIBUTE_UNUSED,
4348
                             const_tree type)
4349
{
4350
  if (!type)
4351
    return false;
4352
 
4353
  /* If the type has variable size...  */
4354
  if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4355
    return true;
4356
 
4357
  /* If the type is marked as addressable (it is required
4358
     to be constructed into the stack)...  */
4359
  if (TREE_ADDRESSABLE (type))
4360
    return true;
4361
 
4362
  return false;
4363
}
4364
 
4365
/* Another version of the TARGET_MUST_PASS_IN_STACK hook.  This one
4366
   takes trailing padding of a structure into account.  */
4367
/* ??? Should be able to merge these two by examining BLOCK_REG_PADDING.  */
4368
 
4369
bool
4370
must_pass_in_stack_var_size_or_pad (enum machine_mode mode, const_tree type)
4371
{
4372
  if (!type)
4373
    return false;
4374
 
4375
  /* If the type has variable size...  */
4376
  if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4377
    return true;
4378
 
4379
  /* If the type is marked as addressable (it is required
4380
     to be constructed into the stack)...  */
4381
  if (TREE_ADDRESSABLE (type))
4382
    return true;
4383
 
4384
  /* If the padding and mode of the type is such that a copy into
4385
     a register would put it into the wrong part of the register.  */
4386
  if (mode == BLKmode
4387
      && int_size_in_bytes (type) % (PARM_BOUNDARY / BITS_PER_UNIT)
4388
      && (FUNCTION_ARG_PADDING (mode, type)
4389
          == (BYTES_BIG_ENDIAN ? upward : downward)))
4390
    return true;
4391
 
4392
  return false;
4393
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.