gcc/stupid.c

   1 /* Dummy data flow analysis for GNU compiler in nonoptimizing mode.
   2    Copyright (C) 1987, 91, 94, 95, 96, 1997 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 /* This file performs stupid register allocation, which is used
  23    when cc1 gets the -noreg switch (which is when cc does not get -O).
  24
  25    Stupid register allocation goes in place of the the flow_analysis,
  26    local_alloc and global_alloc passes.  combine_instructions cannot
  27    be done with stupid allocation because the data flow info that it needs
  28    is not computed here.
  29
  30    In stupid allocation, the only user-defined variables that can
  31    go in registers are those declared "register".  They are assumed
  32    to have a life span equal to their scope.  Other user variables
  33    are given stack slots in the rtl-generation pass and are not
  34    represented as pseudo regs.  A compiler-generated temporary
  35    is assumed to live from its first mention to its last mention.
  36
  37    Since each pseudo-reg's life span is just an interval, it can be
  38    represented as a pair of numbers, each of which identifies an insn by
  39    its position in the function (number of insns before it).  The first
  40    thing done for stupid allocation is to compute such a number for each
  41    insn.  It is called the suid.  Then the life-interval of each
  42    pseudo reg is computed.  Then the pseudo regs are ordered by priority
  43    and assigned hard regs in priority order.  */
  44
  45 #include "config.h"
  46 #include <stdio.h>
  47 #include "rtl.h"
  48 #include "hard-reg-set.h"
  49 #include "regs.h"
  50 #include "flags.h"
  51 \f
  52 /* Vector mapping INSN_UIDs to suids.
  53    The suids are like uids but increase monotonically always.
  54    We use them to see whether a subroutine call came
  55    between a variable's birth and its death.  */
  56
  57 static int *uid_suid;
  58
  59 /* Get the suid of an insn.  */
  60
  61 #define INSN_SUID(INSN) (uid_suid[INSN_UID (INSN)])
  62
  63 /* Record the suid of the last CALL_INSN
  64    so we can tell whether a pseudo reg crosses any calls.  */
  65
  66 static int last_call_suid;
  67
  68 /* Record the suid of the last NOTE_INSN_SETJMP
  69    so we can tell whether a pseudo reg crosses any setjmp.  */
  70
  71 static int last_setjmp_suid;
  72
  73 /* Element N is suid of insn where life span of pseudo reg N ends.
  74    Element is  0 if register N has not been seen yet on backward scan.  */
  75
  76 static int *reg_where_dead;
  77
  78 /* Element N is suid of insn where life span of pseudo reg N begins.  */
  79
  80 static int *reg_where_born;
  81
  82 /* Numbers of pseudo-regs to be allocated, highest priority first.  */
  83
  84 static int *reg_order;
  85
  86 /* Indexed by reg number (hard or pseudo), nonzero if register is live
  87    at the current point in the instruction stream.  */
  88
  89 static char *regs_live;
  90
  91 /* Indexed by reg number, nonzero if reg was used in a SUBREG that changes
  92    its size.  */
  93
  94 static char *regs_change_size;
  95
  96 /* Indexed by reg number, nonzero if reg crosses a setjmp.  */
  97
  98 static char *regs_crosses_setjmp;
  99
 100 /* Indexed by insn's suid, the set of hard regs live after that insn.  */
 101
 102 static HARD_REG_SET *after_insn_hard_regs;
 103
 104 /* Record that hard reg REGNO is live after insn INSN.  */
 105
 106 #define MARK_LIVE_AFTER(INSN,REGNO)  \
 107   SET_HARD_REG_BIT (after_insn_hard_regs[INSN_SUID (INSN)], (REGNO))
 108
 109 static int stupid_reg_compare   PROTO((const GENERIC_PTR,const GENERIC_PTR));
 110 static int stupid_find_reg      PROTO((int, enum reg_class, enum machine_mode,
 111                                        int, int, int));
 112 static void stupid_mark_refs    PROTO((rtx, rtx));
 113 \f
 114 /* Stupid life analysis is for the case where only variables declared
 115    `register' go in registers.  For this case, we mark all
 116    pseudo-registers that belong to register variables as
 117    dying in the last instruction of the function, and all other
 118    pseudo registers as dying in the last place they are referenced.
 119    Hard registers are marked as dying in the last reference before
 120    the end or before each store into them.  */
 121
 122 void
 123 stupid_life_analysis (f, nregs, file)
 124      rtx f;
 125      int nregs;
 126      FILE *file;
 127 {
 128   register int i;
 129   register rtx last, insn;
 130   int max_uid, max_suid;
 131
 132   bzero (regs_ever_live, sizeof regs_ever_live);
 133
 134   regs_live = (char *) alloca (nregs);
 135
 136   /* First find the last real insn, and count the number of insns,
 137      and assign insns their suids.  */
 138
 139   for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
 140     if (INSN_UID (insn) > i)
 141       i = INSN_UID (insn);
 142
 143   max_uid = i + 1;
 144   uid_suid = (int *) alloca ((i + 1) * sizeof (int));
 145
 146   /* Compute the mapping from uids to suids.
 147      Suids are numbers assigned to insns, like uids,
 148      except that suids increase monotonically through the code.  */
 149
 150   last = 0;                     /* In case of empty function body */
 151   for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
 152     {
 153       if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
 154         last = insn;
 155
 156       INSN_SUID (insn) = ++i;
 157     }
 158
 159   last_call_suid = i + 1;
 160   last_setjmp_suid = i + 1;
 161   max_suid = i + 1;
 162
 163   max_regno = nregs;
 164
 165   /* Allocate tables to record info about regs.  */
 166
 167   reg_where_dead = (int *) alloca (nregs * sizeof (int));
 168   bzero ((char *) reg_where_dead, nregs * sizeof (int));
 169
 170   reg_where_born = (int *) alloca (nregs * sizeof (int));
 171   bzero ((char *) reg_where_born, nregs * sizeof (int));
 172
 173   reg_order = (int *) alloca (nregs * sizeof (int));
 174   bzero ((char *) reg_order, nregs * sizeof (int));
 175
 176   regs_change_size = (char *) alloca (nregs * sizeof (char));
 177   bzero ((char *) regs_change_size, nregs * sizeof (char));
 178
 179   regs_crosses_setjmp = (char *) alloca (nregs * sizeof (char));
 180   bzero ((char *) regs_crosses_setjmp, nregs * sizeof (char));
 181
 182   /* Allocate the reg_renumber array */
 183   allocate_reg_info (max_regno, FALSE, TRUE);
 184   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 185     reg_renumber[i] = i;
 186
 187   after_insn_hard_regs
 188     = (HARD_REG_SET *) alloca (max_suid * sizeof (HARD_REG_SET));
 189
 190   bzero ((char *) after_insn_hard_regs, max_suid * sizeof (HARD_REG_SET));
 191
 192   /* Allocate and zero out many data structures
 193      that will record the data from lifetime analysis.  */
 194
 195   allocate_for_life_analysis ();
 196
 197   for (i = 0; i < max_regno; i++)
 198     REG_N_DEATHS (i) = 1;
 199
 200   bzero (regs_live, nregs);
 201
 202   /* Find where each pseudo register is born and dies,
 203      by scanning all insns from the end to the start
 204      and noting all mentions of the registers.
 205
 206      Also find where each hard register is live
 207      and record that info in after_insn_hard_regs.
 208      regs_live[I] is 1 if hard reg I is live
 209      at the current point in the scan.  */
 210
 211   for (insn = last; insn; insn = PREV_INSN (insn))
 212     {
 213       register HARD_REG_SET *p = after_insn_hard_regs + INSN_SUID (insn);
 214
 215       /* Copy the info in regs_live into the element of after_insn_hard_regs
 216          for the current position in the rtl code.  */
 217
 218       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 219         if (regs_live[i])
 220           SET_HARD_REG_BIT (*p, i);
 221
 222       /* Update which hard regs are currently live
 223          and also the birth and death suids of pseudo regs
 224          based on the pattern of this insn.  */
 225
 226       if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
 227         stupid_mark_refs (PATTERN (insn), insn);
 228
 229       if (GET_CODE (insn) == NOTE
 230           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)
 231         last_setjmp_suid = INSN_SUID (insn);
 232
 233       /* Mark all call-clobbered regs as dead after each call insn so that
 234          a pseudo whose life span includes this insn will not go in one of
 235          them.  If the function contains a non-local goto, mark all hard
 236          registers dead (except for stack related bits).
 237
 238          Then mark those regs as all dead for the continuing scan
 239          of the insns before the call.  */
 240
 241       if (GET_CODE (insn) == CALL_INSN)
 242         {
 243           last_call_suid = INSN_SUID (insn);
 244
 245           if (current_function_has_nonlocal_label)
 246             {
 247               IOR_COMPL_HARD_REG_SET (after_insn_hard_regs[last_call_suid],
 248                                       fixed_reg_set);
 249               for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 250                 if (! fixed_regs[i])
 251                   regs_live[i] = 0;
 252             }
 253           else
 254             {
 255               IOR_HARD_REG_SET (after_insn_hard_regs[last_call_suid],
 256                                 call_used_reg_set);
 257               for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 258                 if (call_used_regs[i])
 259                   regs_live[i] = 0;
 260             }
 261
 262           /* It is important that this be done after processing the insn's
 263              pattern because we want the function result register to still
 264              be live if it's also used to pass arguments.  */
 265           stupid_mark_refs (CALL_INSN_FUNCTION_USAGE (insn), insn);
 266         }
 267     }
 268
 269   /* Now decide the order in which to allocate the pseudo registers.  */
 270
 271   for (i = LAST_VIRTUAL_REGISTER + 1; i < max_regno; i++)
 272     reg_order[i] = i;
 273
 274   qsort (&reg_order[LAST_VIRTUAL_REGISTER + 1],
 275          max_regno - LAST_VIRTUAL_REGISTER - 1, sizeof (int),
 276          stupid_reg_compare);
 277
 278   /* Now, in that order, try to find hard registers for those pseudo regs.  */
 279
 280   for (i = LAST_VIRTUAL_REGISTER + 1; i < max_regno; i++)
 281     {
 282       register int r = reg_order[i];
 283
 284       /* Some regnos disappear from the rtl.  Ignore them to avoid crash.
 285          Also don't allocate registers that cross a setjmp, or live across
 286          a call if this function receives a nonlocal goto.  */
 287       if (regno_reg_rtx[r] == 0 || regs_crosses_setjmp[r]
 288           || (REG_N_CALLS_CROSSED (r) > 0
 289               && current_function_has_nonlocal_label))
 290         continue;
 291
 292       /* Now find the best hard-register class for this pseudo register */
 293       if (N_REG_CLASSES > 1)
 294         reg_renumber[r] = stupid_find_reg (REG_N_CALLS_CROSSED (r),
 295                                            reg_preferred_class (r),
 296                                            PSEUDO_REGNO_MODE (r),
 297                                            reg_where_born[r],
 298                                            reg_where_dead[r],
 299                                            regs_change_size[r]);
 300
 301       /* If no reg available in that class, try alternate class.  */
 302       if (reg_renumber[r] == -1 && reg_alternate_class (r) != NO_REGS)
 303         reg_renumber[r] = stupid_find_reg (REG_N_CALLS_CROSSED (r),
 304                                            reg_alternate_class (r),
 305                                            PSEUDO_REGNO_MODE (r),
 306                                            reg_where_born[r],
 307                                            reg_where_dead[r],
 308                                            regs_change_size[r]);
 309     }
 310
 311   if (file)
 312     dump_flow_info (file);
 313 }
 314
 315 /* Comparison function for qsort.
 316    Returns -1 (1) if register *R1P is higher priority than *R2P.  */
 317
 318 static int
 319 stupid_reg_compare (r1p, r2p)
 320      const GENERIC_PTR r1p;
 321      const GENERIC_PTR r2p;
 322 {
 323   register int r1 = *(int *)r1p, r2 = *(int *)r2p;
 324   register int len1 = reg_where_dead[r1] - reg_where_born[r1];
 325   register int len2 = reg_where_dead[r2] - reg_where_born[r2];
 326   int tem;
 327
 328   tem = len2 - len1;
 329   if (tem != 0)
 330     return tem;
 331
 332   tem = REG_N_REFS (r1) - REG_N_REFS (r2);
 333   if (tem != 0)
 334     return tem;
 335
 336   /* If regs are equally good, sort by regno,
 337      so that the results of qsort leave nothing to chance.  */
 338   return r1 - r2;
 339 }
 340 \f
 341 /* Find a block of SIZE words of hard registers in reg_class CLASS
 342    that can hold a value of machine-mode MODE
 343      (but actually we test only the first of the block for holding MODE)
 344    currently free from after insn whose suid is BORN_INSN
 345    through the insn whose suid is DEAD_INSN,
 346    and return the number of the first of them.
 347    Return -1 if such a block cannot be found.
 348
 349    If CALL_PRESERVED is nonzero, insist on registers preserved
 350    over subroutine calls, and return -1 if cannot find such.
 351
 352    If CHANGES_SIZE is nonzero, it means this register was used as the
 353    operand of a SUBREG that changes its size.  */
 354
 355 static int
 356 stupid_find_reg (call_preserved, class, mode,
 357                  born_insn, dead_insn, changes_size)
 358      int call_preserved;
 359      enum reg_class class;
 360      enum machine_mode mode;
 361      int born_insn, dead_insn;
 362      int changes_size;
 363 {
 364   register int i, ins;
 365 #ifdef HARD_REG_SET
 366   register              /* Declare them register if they are scalars.  */
 367 #endif
 368     HARD_REG_SET used, this_reg;
 369 #ifdef ELIMINABLE_REGS
 370   static struct {int from, to; } eliminables[] = ELIMINABLE_REGS;
 371 #endif
 372
 373   /* If this register's life is more than 5,000 insns, we probably
 374      can't allocate it, so don't waste the time trying.  This avoids
 375      quadratic behavior on programs that have regularly-occurring
 376      SAVE_EXPRs.  */
 377   if (dead_insn > born_insn + 5000)
 378     return -1;
 379
 380   COPY_HARD_REG_SET (used,
 381                      call_preserved ? call_used_reg_set : fixed_reg_set);
 382
 383 #ifdef ELIMINABLE_REGS
 384   for (i = 0; i < sizeof eliminables / sizeof eliminables[0]; i++)
 385     SET_HARD_REG_BIT (used, eliminables[i].from);
 386 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
 387   SET_HARD_REG_BIT (used, HARD_FRAME_POINTER_REGNUM);
 388 #endif
 389 #else
 390   SET_HARD_REG_BIT (used, FRAME_POINTER_REGNUM);
 391 #endif
 392
 393   for (ins = born_insn; ins < dead_insn; ins++)
 394     IOR_HARD_REG_SET (used, after_insn_hard_regs[ins]);
 395
 396   IOR_COMPL_HARD_REG_SET (used, reg_class_contents[(int) class]);
 397
 398 #ifdef CLASS_CANNOT_CHANGE_SIZE
 399   if (changes_size)
 400     IOR_HARD_REG_SET (used,
 401                       reg_class_contents[(int) CLASS_CANNOT_CHANGE_SIZE]);
 402 #endif
 403
 404   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 405     {
 406 #ifdef REG_ALLOC_ORDER
 407       int regno = reg_alloc_order[i];
 408 #else
 409       int regno = i;
 410 #endif
 411
 412       /* If a register has screwy overlap problems,
 413          don't use it at all if not optimizing.
 414          Actually this is only for the 387 stack register,
 415          and it's because subsequent code won't work.  */
 416 #ifdef OVERLAPPING_REGNO_P
 417       if (OVERLAPPING_REGNO_P (regno))
 418         continue;
 419 #endif
 420
 421       if (! TEST_HARD_REG_BIT (used, regno)
 422           && HARD_REGNO_MODE_OK (regno, mode))
 423         {
 424           register int j;
 425           register int size1 = HARD_REGNO_NREGS (regno, mode);
 426           for (j = 1; j < size1 && ! TEST_HARD_REG_BIT (used, regno + j); j++);
 427           if (j == size1)
 428             {
 429               CLEAR_HARD_REG_SET (this_reg);
 430               while (--j >= 0)
 431                 SET_HARD_REG_BIT (this_reg, regno + j);
 432               for (ins = born_insn; ins < dead_insn; ins++)
 433                 {
 434                   IOR_HARD_REG_SET (after_insn_hard_regs[ins], this_reg);
 435                 }
 436               return regno;
 437             }
 438 #ifndef REG_ALLOC_ORDER
 439           i += j;               /* Skip starting points we know will lose */
 440 #endif
 441         }
 442     }
 443
 444   return -1;
 445 }
 446 \f
 447 /* Walk X, noting all assignments and references to registers
 448    and recording what they imply about life spans.
 449    INSN is the current insn, supplied so we can find its suid.  */
 450
 451 static void
 452 stupid_mark_refs (x, insn)
 453      rtx x, insn;
 454 {
 455   register RTX_CODE code;
 456   register char *fmt;
 457   register int regno, i;
 458
 459   if (x == 0)
 460     return;
 461
 462   code = GET_CODE (x);
 463
 464   if (code == SET || code == CLOBBER)
 465     {
 466       if (SET_DEST (x) != 0
 467           && (GET_CODE (SET_DEST (x)) == REG
 468               || (GET_CODE (SET_DEST (x)) == SUBREG
 469                   && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
 470                   && (REGNO (SUBREG_REG (SET_DEST (x)))
 471                       >= FIRST_PSEUDO_REGISTER))))
 472         {
 473           /* Register is being assigned.  */
 474           /* If setting a SUBREG, we treat the entire reg as being set.  */
 475           if (GET_CODE (SET_DEST (x)) == SUBREG)
 476             regno = REGNO (SUBREG_REG (SET_DEST (x)));
 477           else
 478             regno = REGNO (SET_DEST (x));
 479
 480           /* For hard regs, update the where-live info.  */
 481           if (regno < FIRST_PSEUDO_REGISTER)
 482             {
 483               register int j
 484                 = HARD_REGNO_NREGS (regno, GET_MODE (SET_DEST (x)));
 485
 486               while (--j >= 0)
 487                 {
 488                   regs_ever_live[regno+j] = 1;
 489                   regs_live[regno+j] = 0;
 490
 491                   /* The following line is for unused outputs;
 492                      they do get stored even though never used again.  */
 493                   MARK_LIVE_AFTER (insn, regno+j);
 494
 495                   /* When a hard reg is clobbered, mark it in use
 496                      just before this insn, so it is live all through.  */
 497                   if (code == CLOBBER && INSN_SUID (insn) > 0)
 498                     SET_HARD_REG_BIT (after_insn_hard_regs[INSN_SUID (insn) - 1],
 499                                       regno+j);
 500                 }
 501             }
 502           /* For pseudo regs, record where born, where dead, number of
 503              times used, and whether live across a call.  */
 504           else
 505             {
 506               /* Update the life-interval bounds of this pseudo reg.  */
 507
 508               /* When a pseudo-reg is CLOBBERed, it is born just before
 509                  the clobbering insn.  When setting, just after.  */
 510               int where_born = INSN_SUID (insn) - (code == CLOBBER);
 511
 512               reg_where_born[regno] = where_born;
 513
 514               /* The reg must live at least one insn even
 515                  in it is never again used--because it has to go
 516                  in SOME hard reg.  Mark it as dying after the current
 517                  insn so that it will conflict with any other outputs of
 518                  this insn.  */
 519               if (reg_where_dead[regno] < where_born + 2)
 520                 {
 521                   reg_where_dead[regno] = where_born + 2;
 522                   regs_live[regno] = 1;
 523                 }
 524
 525               /* Count the refs of this reg.  */
 526               REG_N_REFS (regno)++;
 527
 528               if (last_call_suid < reg_where_dead[regno])
 529                 REG_N_CALLS_CROSSED (regno) += 1;
 530
 531               if (last_setjmp_suid < reg_where_dead[regno])
 532                 regs_crosses_setjmp[regno] = 1;
 533
 534               /* If this register is only used in this insn and is only
 535                  set, mark it unused.  We have to do this even when not
 536                  optimizing so that MD patterns which count on this
 537                  behavior (e.g., it not causing an output reload on
 538                  an insn setting CC) will operate correctly.  */
 539               if (GET_CODE (SET_DEST (x)) == REG
 540                   && REGNO_FIRST_UID (regno) == INSN_UID (insn)
 541                   && REGNO_LAST_UID (regno) == INSN_UID (insn)
 542                   && (code == CLOBBER || ! reg_mentioned_p (SET_DEST (x),
 543                                                             SET_SRC (x))))
 544                 REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_UNUSED,
 545                                                       SET_DEST (x),
 546                                                       REG_NOTES (insn));
 547             }
 548         }
 549
 550       /* Record references from the value being set,
 551          or from addresses in the place being set if that's not a reg.
 552          If setting a SUBREG, we treat the entire reg as *used*.  */
 553       if (code == SET)
 554         {
 555           stupid_mark_refs (SET_SRC (x), insn);
 556           if (GET_CODE (SET_DEST (x)) != REG)
 557             stupid_mark_refs (SET_DEST (x), insn);
 558         }
 559       return;
 560     }
 561
 562   else if (code == SUBREG
 563            && GET_CODE (SUBREG_REG (x)) == REG
 564            && REGNO (SUBREG_REG (x)) >= FIRST_PSEUDO_REGISTER
 565            && (GET_MODE_SIZE (GET_MODE (x))
 566                != GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
 567            && (INTEGRAL_MODE_P (GET_MODE (x))
 568                || INTEGRAL_MODE_P (GET_MODE (SUBREG_REG (x)))))
 569     regs_change_size[REGNO (SUBREG_REG (x))] = 1;
 570
 571   /* Register value being used, not set.  */
 572
 573   else if (code == REG)
 574     {
 575       regno = REGNO (x);
 576       if (regno < FIRST_PSEUDO_REGISTER)
 577         {
 578           /* Hard reg: mark it live for continuing scan of previous insns.  */
 579           register int j = HARD_REGNO_NREGS (regno, GET_MODE (x));
 580           while (--j >= 0)
 581             {
 582               regs_ever_live[regno+j] = 1;
 583               regs_live[regno+j] = 1;
 584             }
 585         }
 586       else
 587         {
 588           /* Pseudo reg: record first use, last use and number of uses.  */
 589
 590           reg_where_born[regno] = INSN_SUID (insn);
 591           REG_N_REFS (regno)++;
 592           if (regs_live[regno] == 0)
 593             {
 594               regs_live[regno] = 1;
 595               reg_where_dead[regno] = INSN_SUID (insn);
 596             }
 597         }
 598       return;
 599     }
 600
 601   /* Recursive scan of all other rtx's.  */
 602
 603   fmt = GET_RTX_FORMAT (code);
 604   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 605     {
 606       if (fmt[i] == 'e')
 607         stupid_mark_refs (XEXP (x, i), insn);
 608       if (fmt[i] == 'E')
 609         {
 610           register int j;
 611           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 612             stupid_mark_refs (XVECEXP (x, i, j), insn);
 613         }
 614     }
 615 }