config/ia64/ia64.c

144 /* Variables which are this size or smaller are put in the sdata/sbss
681 /* Variable tracking should be run after all optimizations which
809 /* Part of the low level implementation of DEC Ada pragma Common_Object which
906      the validity of the underlying address, which should have been
1431    May return an insn which is to be emitted after the moves.  */
1495 		/* Reversal requires a pre-increment, which can only
1658    (subreg:XF (reg:TI)), which we got from a union containing a long double.
1683 /* Expand the movxf or movrf pattern (MODE says which) with the given
1833   /* HPUX TFmode compare requires a library call to _U_Qfcmp, which takes a
2441   /* Because of the volatile mem read, we get an ld.acq, which is the
2780   /* Discover which registers need spilling, and how much room that
2782      which will always wind up on the stack.  */
2977      if we are a leaf function, there's no one to which we need to provide
3033 	 in which case we store through the 16 byte save area.  */
3069   rtx_insn *init_after;		/* point at which to emit initializations */
3148      CFA 0, which may allow the real iterator to be initialized lower,
3321   /* Compute the address of the probe for the Backing Store (which grows
3326      size is at least 4096 - (96 + 2) * 8 = 3312 bytes, which is enough.
3328      (which grows towards lower addresses).  */
3583      for GNU libc, which creates crti.S/crtn.S by splitting initfini.c in
3739      bits from varargs, which we don't care about.  */
4555    for the last named argument which has type TYPE and mode MODE.
5560 	const char *which;
5572 	      which = ".spnt";
5574 	      which = ".dpnt";
5577 	      which = ".dptk";
5579 	      which = ".sptk";
5582 	  which = ".sptk";
5584 	  which = ".dptk";
5586 	fputs (which, file);
5694          which normally involves copies.  Plus there's the latency
5878 	 both of which are equiv to the same constant, and both which need
5880 	 changes depending on the path length, which means the qty_first_reg
6164 /* This is used for volatile asms which may require a stop bit immediately
6248    in which case we don't need another stop bit.  Without this,
6275 /* Update *RWS for REGNO, which is being written by the current instruction,
6426 /* Examine X, which is a SET rtx, and update the flags, the predicate, and
6441 	 (1) The destination is (pc), in which case this is a branch,
6443 	 (2) The destination is ar.lc, in which case this is a
6445 	 (3) The destination is an fp register, in which case this is
6447 	 (4) The condition has (unspec [(reg)] UNSPEC_LDC), in which case
6609 	 by the ASM_INPUT rtx inside ASM_OPERANDS, which do not indicate
7027    instruction scheduling pass has been run which has already
7320   /* Before reload, which_alternative is not set, which means that
7658     /* We could hit a NOTE_INSN_DELETED here which is actually outside
8532 /* The following page contains abstract data `bundle states' which are
8924    because undocumented anomaly in McKinley derived cores which can
9091    reject some decisions which cannot improve the solution and
9141   /* Shift cycle mark if it is put on insn which could be ignored.  */
9703       /* Skip p0, which may be thought to be live due to (reg:DI p0)
9924 	 which in turn makes it possible to restart a system call after
9936       /* Likewise for ar.pfs, which is used by br.ret.  */
9971    types which can't go in sdata/sbss.  */
10729      use them instead of _U_Qfcmp, which doesn't work the way we
11558 	  unsigned which = i / 2 + (i & 1 ? nelt : 0);
11559 	  remap[which] = i;
11560 	  dremap.perm[i] = which;
11567 	  unsigned which = i / 2 + nelt2 + (i & 1 ? nelt : 0);
11568 	  remap[which] = i;
11569 	  dremap.perm[i] = which;
11576 	  unsigned which = (i & ~1) + (i & 1 ? nelt : 0);
11577 	  remap[which] = i;
11578 	  dremap.perm[i] = which;
11585 	  unsigned which = (i | 1) + (i & 1 ? nelt : 0);
11586 	  remap[which] = i;
11587 	  dremap.perm[i] = which;
11595 	  unsigned which = (i + shift) & (2 * nelt - 1);
11596 	  remap[which] = i;
11597 	  dremap.perm[i] = which;
11707   int i, nelt, which;
11724   for (i = which = 0; i < nelt; ++i)
11729       which |= (ei < nelt ? 1 : 2);
11734   switch (which)
11774   if (which == 3 && d.one_operand_p)
11791   unsigned int i, nelt, which;
11801   for (i = which = 0; i < nelt; ++i)
11805       which |= (e < nelt ? 1 : 2);
11809   if (which == 2)
11814   d.one_operand_p = (which != 3);
11834   unsigned int which;
11845   which = INTVAL (operands[2]);
11846   gcc_assert (which <= 1);
11847   d.perm[0] = 1 - which;
11848   d.perm[1] = which + 2;