[llvm-commits] [llvm-gcc-4.2] r54192 - in /llvm-gcc-4.2/trunk/gcc: config/i386/i386.c global.c local-alloc.c tree-pass.h
Bill Wendling
isanbard at gmail.com
Tue Jul 29 20:35:19 PDT 2008
Author: void
Date: Tue Jul 29 22:35:16 2008
New Revision: 54192
URL: http://llvm.org/viewvc/llvm-project?rev=54192&view=rev
Log:
Merges from Apple's GCC 4.2 r148430
Modified:
llvm-gcc-4.2/trunk/gcc/config/i386/i386.c
llvm-gcc-4.2/trunk/gcc/global.c
llvm-gcc-4.2/trunk/gcc/local-alloc.c
llvm-gcc-4.2/trunk/gcc/tree-pass.h
Modified: llvm-gcc-4.2/trunk/gcc/config/i386/i386.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/gcc/config/i386/i386.c?rev=54192&r1=54191&r2=54192&view=diff
==============================================================================
--- llvm-gcc-4.2/trunk/gcc/config/i386/i386.c (original)
+++ llvm-gcc-4.2/trunk/gcc/config/i386/i386.c Tue Jul 29 22:35:16 2008
@@ -1261,7 +1261,6 @@
ATTRIBUTE_UNUSED;
/* LLVM LOCAL begin */
-
#ifndef ENABLE_LLVM
/* Register class used for passing given 64bit part of the argument.
These represent classes as documented by the PS ABI, with the exception
@@ -1286,9 +1285,7 @@
X86_64_MEMORY_CLASS
};
#endif /* !ENABLE_LLVM */
-
/* LLVM LOCAL end */
-
static const char * const x86_64_reg_class_name[] = {
"no", "integer", "integerSI", "sse", "sseSF", "sseDF",
"sseup", "x87", "x87up", "cplx87", "no"
@@ -5233,7 +5230,8 @@
# define USE_HIDDEN_LINKONCE 0
#endif
-static int pic_labels_used;
+/* APPLE LOCAL 5695218 */
+static GTY(()) int pic_labels_used;
/* Fills in the label name that should be used for a pc thunk for
the given register. */
@@ -5424,6 +5422,49 @@
return INVALID_REGNUM;
}
+/* APPLE LOCAL begin 5695218 */
+/* Reload may introduce references to the PIC base register
+ that do not directly reference pic_offset_table_rtx.
+ In the rare event we choose an alternate PIC register,
+ walk all the insns and rewrite every reference. */
+/* Run through the insns, changing references to the original
+ PIC_OFFSET_TABLE_REGNUM to our new one. */
+static void
+ix86_globally_replace_pic_reg (unsigned int new_pic_regno)
+{
+ rtx insn;
+ const int nregs = PIC_OFFSET_TABLE_REGNUM + 1;
+ rtx reg_map[FIRST_PSEUDO_REGISTER];
+ memset (reg_map, 0, nregs * sizeof (rtx));
+ pic_offset_table_rtx = gen_rtx_REG (SImode, new_pic_regno);
+ reg_map[REAL_PIC_OFFSET_TABLE_REGNUM] = pic_offset_table_rtx;
+
+ push_topmost_sequence ();
+ for (insn = get_insns (); insn != NULL; insn = NEXT_INSN (insn))
+ {
+ if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN)
+ {
+ replace_regs (PATTERN (insn), reg_map, nregs, 1);
+ replace_regs (REG_NOTES (insn), reg_map, nregs, 1);
+ }
+#if defined (TARGET_TOC)
+ else if (GET_CODE (insn) == CALL_INSN)
+ {
+ if ( !SIBLING_CALL_P (insn))
+ abort ();
+ }
+#endif
+ }
+ pop_topmost_sequence ();
+
+ regs_ever_live[new_pic_regno] = 1;
+ regs_ever_live[PIC_OFFSET_TABLE_REGNUM] = 0;
+#if defined (TARGET_TOC)
+ cfun->machine->substitute_pic_base_reg = new_pic_regno;
+#endif
+}
+/* APPLE LOCAL end 5695218 */
+
/* Return 1 if we need to save REGNO. */
static int
ix86_save_reg (unsigned int regno, int maybe_eh_return)
@@ -5437,10 +5478,12 @@
if (pic_offset_table_rtx
&& regno == REAL_PIC_OFFSET_TABLE_REGNUM
- && (regs_ever_live[REAL_PIC_OFFSET_TABLE_REGNUM]
+ /* APPLE LOCAL begin 5695218 */
+ && (current_function_uses_pic_offset_table
|| current_function_profile
|| current_function_calls_eh_return
|| current_function_uses_const_pool))
+ /* APPLE LOCAL end 5695218 */
{
if (ix86_select_alt_pic_regnum () != INVALID_REGNUM)
return 0;
@@ -5464,6 +5507,16 @@
&& regno == REGNO (cfun->machine->force_align_arg_pointer))
return 1;
+ /* APPLE LOCAL begin 5695218 */
+ /* In order to get accurate usage info for the PIC register, we've
+ been forced to break and un-break the call_used_regs and
+ fixed_regs vectors. Ignore them when considering the PIC
+ register. */
+ if (regno == REAL_PIC_OFFSET_TABLE_REGNUM
+ && regs_ever_live[regno])
+ return 1;
+ /* APPLE LOCAL end 5695218 */
+
return (regs_ever_live[regno]
&& !call_used_regs[regno]
&& !fixed_regs[regno]
@@ -6008,14 +6061,20 @@
}
pic_reg_used = false;
- if (pic_offset_table_rtx
- && (regs_ever_live[REAL_PIC_OFFSET_TABLE_REGNUM]
- || current_function_profile))
+ /* APPLE LOCAL begin 5695218 */
+ if (pic_offset_table_rtx && regs_ever_live[REAL_PIC_OFFSET_TABLE_REGNUM]
+ && !TARGET_64BIT)
{
- unsigned int alt_pic_reg_used = ix86_select_alt_pic_regnum ();
+ unsigned int alt_pic_reg_used;
+
+ alt_pic_reg_used = ix86_select_alt_pic_regnum ();
+ /* APPLE LOCAL end 5695218 */
if (alt_pic_reg_used != INVALID_REGNUM)
- REGNO (pic_offset_table_rtx) = alt_pic_reg_used;
+ /* APPLE LOCAL begin 5695218 */
+ /* REGNO (pic_offset_table_rtx) = alt_pic_reg_used; */
+ ix86_globally_replace_pic_reg (alt_pic_reg_used);
+ /* APPLE LOCAL end 5695218 */
pic_reg_used = true;
}
@@ -18927,7 +18986,8 @@
return TARGET_64BIT || !TARGET_PARTIAL_REG_STALL;
case DImode:
- return TARGET_64BIT;
+ /* APPLE LOCAL 5695218 convert int to logical bool */
+ return !!TARGET_64BIT;
default:
return false;
@@ -19763,7 +19823,7 @@
{
int tmp_regno = 2 /* ECX */;
if (lookup_attribute ("fastcall",
- TYPE_ATTRIBUTES (TREE_TYPE (function))))
+ TYPE_ATTRIBUTES (TREE_TYPE (function))))
tmp_regno = 0 /* EAX */;
tmp = gen_rtx_REG (SImode, tmp_regno);
}
Modified: llvm-gcc-4.2/trunk/gcc/global.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/gcc/global.c?rev=54192&r1=54191&r2=54192&view=diff
==============================================================================
--- llvm-gcc-4.2/trunk/gcc/global.c (original)
+++ llvm-gcc-4.2/trunk/gcc/global.c Tue Jul 29 22:35:16 2008
@@ -455,17 +455,17 @@
{
bool cannot_elim
= (! CAN_ELIMINATE (eliminables[i].from, eliminables[i].to)
-/* APPLE LOCAL begin ARM prefer SP to FP */
+ /* APPLE LOCAL begin ARM prefer SP to FP */
#ifdef ALLOW_ELIMINATION_TO_SP
/* There are certain performance benefits for some targets
in using SP instead of FP. CAN_ELIMINATE must prevent us
from using SP when we can't so there's no need for us to
prevent elimination to the SP. */
- );
#else
- || (eliminables[i].to == STACK_POINTER_REGNUM && need_fp));
+ || (eliminables[i].to == STACK_POINTER_REGNUM && need_fp)
#endif
-/* APPLE LOCAL end ARM prefer SP to FP */
+ );
+ /* APPLE LOCAL end ARM prefer SP to FP */
if (!regs_asm_clobbered[eliminables[i].from])
{
@@ -494,7 +494,7 @@
error ("%s cannot be used in asm here",
reg_names[HARD_FRAME_POINTER_REGNUM]);
}
- /* APPLE LOCAL end CW asm blocks 4443946 */
+ /* APPLE LOCAL end CW asm blocks 4443946 */
else
regs_ever_live[HARD_FRAME_POINTER_REGNUM] = 1;
#endif
@@ -782,6 +782,18 @@
free (allocno_order);
}
+ /* APPLE LOCAL begin 5695218 */
+#ifdef TARGET_386
+ if ((flag_pic && !TARGET_64BIT) || PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
+ {
+ fixed_regs[REAL_PIC_OFFSET_TABLE_REGNUM] = call_used_regs[REAL_PIC_OFFSET_TABLE_REGNUM] = 1;
+ SET_HARD_REG_BIT (call_fixed_reg_set, REAL_PIC_OFFSET_TABLE_REGNUM);
+ SET_HARD_REG_BIT (fixed_reg_set, REAL_PIC_OFFSET_TABLE_REGNUM);
+ SET_HARD_REG_BIT (call_used_reg_set, REAL_PIC_OFFSET_TABLE_REGNUM);
+ }
+#endif
+ /* APPLE LOCAL end 5695218 */
+
/* Do the reloads now while the allocno data still exists, so that we can
try to assign new hard regs to any pseudo regs that are spilled. */
@@ -826,6 +838,22 @@
= (((double) (floor_log2 (allocno[v2].n_refs) * allocno[v2].freq)
/ allocno[v2].live_length)
* (10000 / REG_FREQ_MAX) * allocno[v2].size);
+ /* APPLE LOCAL begin 5695218 */
+ /* DImode pseudos get 2x the priority of SImode pseudos because
+ their size (2x sizeof(SImode)) is factored in above. Since
+ HImode and QImode pseudoes are restricted to a subset of integer
+ registers on x86_32, give them more priority than SImode pseudos,
+ but less than DImode pseudos. */
+#if defined(TARGET_386)
+ if (flag_global_alloc_prefer_bytes && !TARGET_64BIT)
+ {
+ if (reg_preferred_class (allocno[v1].reg) == Q_REGS)
+ pri1 = (double)pri1 * 1.9;
+ if (reg_preferred_class (allocno[v2].reg) == Q_REGS)
+ pri2 = (double)pri2 * 1.9;
+ }
+#endif
+ /* APPLE LOCAL end 5695218 */
if (pri2 - pri1)
return pri2 - pri1;
@@ -1812,6 +1840,7 @@
{
int k, l;
/* Mark tied pseudo-regs that have not yet been assigned a reg
+ and do not already have a hard reg preference
and do not conflict as preferring this reg. Mark pseudo-regs
conflicting with regs tied to this reg and not yet assigned a
reg as not preferring this reg. */
@@ -1858,7 +1887,6 @@
void
retry_global_alloc (int regno, HARD_REG_SET forbidden_regs)
{
-
int alloc_no = reg_allocno[regno];
/* LLVM LOCAL begin - cc1 code size. */
#ifdef ENABLE_LLVM
@@ -2343,9 +2371,15 @@
orig_regno = ORIGINAL_REGNO (r);
if (orig_regno < FIRST_PSEUDO_REGISTER || regno >= FIRST_PSEUDO_REGISTER)
continue;
+ /* APPLE LOCAL begin 5695218 */
if (regno == orig_regno)
continue;
+ if (orig_regno >= max_regno)
+ continue;
i = reg_allocno[orig_regno];
+ if (i < 0)
+ continue;
+ /* APPLE LOCAL end 5695218 */
EXECUTE_IF_SET_IN_ALLOCNO_SET(pseudo_preferences + i * allocno_row_words, j,
{
if (i != j
@@ -2648,21 +2682,55 @@
int i, j;
fprintf (file, ";; Register dispositions:\n");
+ /* APPLE LOCAL begin 5695218 */
for (i = FIRST_PSEUDO_REGISTER, j = 0; i < max_regno; i++)
- if (reg_renumber[i] >= 0)
- {
- fprintf (file, "%d in %d ", i, reg_renumber[i]);
- if (++j % 6 == 0)
- fprintf (file, "\n");
- }
+ {
+ if (!REG_P (regno_reg_rtx[i]))
+ fprintf (file, "pseudo %d: ", i);
+ print_inline_rtx (file, regno_reg_rtx[i], 0);
+ if (reg_renumber[i] > -1)
+ fprintf (file, " w=" HOST_WIDE_INT_PRINT_DEC, local_reg_weight[reg_renumber[i]]);
+ fprintf (file, "\n");
+ }
+ /* APPLE LOCAL end 5695218 */
fprintf (file, "\n\n;; Hard regs used: ");
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if (regs_ever_live[i])
- fprintf (file, " %d", i);
+ /* APPLE LOCAL 5695218 */
+ fprintf (file, " %d/%s", i, reg_names[i]);
fprintf (file, "\n\n");
}
+/* APPLE LOCAL begin 5695218 */
+/* Print out the current global register assignments. Invoked from the debugger. */
+void debug_global_regs (void);
+void
+debug_global_regs (void)
+{
+ dump_global_regs (stdout);
+}
+void dump_hard_regset (FILE *, HARD_REG_SET);
+void dump_hard_regset (FILE *file, HARD_REG_SET regset)
+{
+ int i;
+ long long unsigned int ulli;
+ for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
+ {
+ ulli = (1LL << i);
+ if (TEST_HARD_REG_BIT (regset, i) && *reg_names[i])
+ fprintf (file, " %d=0x%llx/%s", i, ulli, reg_names[i]);
+ }
+ fprintf (file, "\n");
+}
+/* Print out the registers in a hard REGSET. Invoked from the debugger. */
+void debug_hard_regset (HARD_REG_SET);
+void debug_hard_regset (HARD_REG_SET regset)
+{
+ dump_hard_regset (stdout, regset);
+}
+/* APPLE LOCAL end 5695218 */
+
/* This page contains code to make live information more accurate.
Modified: llvm-gcc-4.2/trunk/gcc/local-alloc.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/gcc/local-alloc.c?rev=54192&r1=54191&r2=54192&view=diff
==============================================================================
--- llvm-gcc-4.2/trunk/gcc/local-alloc.c (original)
+++ llvm-gcc-4.2/trunk/gcc/local-alloc.c Tue Jul 29 22:35:16 2008
@@ -292,6 +292,19 @@
/* Nonzero if we recorded an equivalence for a LABEL_REF. */
static int recorded_label_ref;
+/* APPLE LOCAL begin 5695218 */
+/* Pseudo registers that inherit from the PIC_OFFSET_TABLE_RTX have
+ their bit set here. Used to predict when a not-yet-allocated
+ pseudo-register might turn into a pic reference during reload. */
+GTY(()) sbitmap pic_rtx_inheritance;
+/* max_allocno by max_allocno array of bits, recording inheritance;
+ bits j and k set in row m mean that allocno m was set by a
+ computation involving j and k. */
+static GTY(()) sbitmap *reg_inheritance_matrix;
+static int reg_inheritance_1 (rtx *, void *);
+static void reg_inheritance (void);
+/* APPLE LOCAL end 5695218 */
+
static void alloc_qty (int, enum machine_mode, int, int);
static void validate_equiv_mem_from_store (rtx, rtx, void *);
static int validate_equiv_mem (rtx, rtx, rtx);
@@ -365,10 +378,28 @@
ORDER_REGS_FOR_LOCAL_ALLOC;
#endif
+ /* APPLE LOCAL begin 5695218 */
+ gcc_assert (!reg_inheritance_matrix);
+ if (PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
+ {
+ reg_inheritance_matrix = sbitmap_vector_alloc (max_regno, max_regno);
+ sbitmap_vector_zero (reg_inheritance_matrix, max_regno);
+ }
+ /* APPLE LOCAL end 5695218 */
+
/* Promote REG_EQUAL notes to REG_EQUIV notes and adjust status of affected
registers. */
update_equiv_regs ();
+ /* APPLE LOCAL begin 5695218 */
+ if (PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
+ {
+ reg_inheritance ();
+ sbitmap_vector_free (reg_inheritance_matrix);
+ reg_inheritance_matrix = (sbitmap *)0;
+ }
+ /* APPLE LOCAL end 5695218 */
+
/* This sets the maximum number of quantities we can have. Quantity
numbers start at zero and we can have one for each pseudo. */
max_qty = (max_regno - FIRST_PSEUDO_REGISTER);
@@ -861,6 +892,18 @@
dest = SET_DEST (set);
src = SET_SRC (set);
+ /* APPLE LOCAL begin 5695218 */
+ if (PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
+ {
+ int dstregno;
+ if (REG_P (dest))
+ {
+ dstregno = REGNO (dest);
+ for_each_rtx (&src, reg_inheritance_1, (void*)dstregno);
+ }
+ }
+ /* APPLE LOCAL end 5695218 */
+
/* See if this is setting up the equivalence between an argument
register and its stack slot. */
note = find_reg_note (insn, REG_EQUIV, NULL_RTX);
@@ -2565,6 +2608,139 @@
}
#endif
/* APPLE LOCAL end radar 4216496, 4229407, 4120689, 4095567 */
+
+/* APPLE LOCAL begin 5695218 */
+static void dump_inheritance (FILE *);
+static void
+dump_inheritance (FILE *dumpfile)
+{
+ sbitmap_iterator sbiter;
+ unsigned int ui;
+ int emitted, width;
+ fprintf (dumpfile, ";; FIRST_PSEUDO_REGISTER = %d, max_regno = %d\n", FIRST_PSEUDO_REGISTER, max_regno);
+ dump_sbitmap_vector (dumpfile, ";; register inheritance matrix:", ";; register", reg_inheritance_matrix, max_regno);
+ if (pic_rtx_inheritance)
+ {
+ fprintf (dumpfile, "\n;; pic_rtx_inheritance bitmap:\n");
+ dump_sbitmap (dumpfile, pic_rtx_inheritance);
+ fprintf (dumpfile, "\n;; pseudo-regs that inherit PIC_OFFSET_TABLE_REGNUM (=%d):\n",
+ PIC_OFFSET_TABLE_REGNUM);
+ width = 0;
+ EXECUTE_IF_SET_IN_SBITMAP (pic_rtx_inheritance, FIRST_PSEUDO_REGISTER, ui, sbiter)
+ {
+ emitted = fprintf (dumpfile, " %d,", ui);
+ gcc_assert (emitted >= 0);
+ width += emitted;
+ if (width > 75)
+ {
+ width = 0;
+ fprintf (dumpfile, "\n");
+ }
+ }
+ fprintf (dumpfile, "\n\n");
+ }
+ else
+ fprintf (dumpfile, ";; pic_rtx_inheritance=0\n");
+}
+void debug_inheritance (void);
+void
+debug_inheritance (void)
+{
+ dump_inheritance (stdout);
+}
+/* If we've walked into a SUBREG or REG, record it as inherited. See
+ reg_inheritance() below. */
+static int
+reg_inheritance_1 (rtx *px, void *data)
+{
+ rtx x = *px;
+ unsigned int srcregno, dstregno;
+
+ dstregno = (int)data;
+#ifdef TARGET_386
+ /* Ugly special case: When moving a DImode constant into an FP
+ register, GCC will use the movdf_nointeger pattern, pushing the
+ DImode constant into memory and loading into the '387. It looks
+ like this: (set (reg:DF) (subreg:DF (reg:DI))). We're choosing
+ to match the subreg; hope this is sufficient.
+ */
+ if (GET_CODE (x) == SUBREG
+ && GET_MODE (x) == DFmode
+ && GET_MODE (SUBREG_REG (x)) == DImode)
+ {
+ SET_BIT (reg_inheritance_matrix[dstregno], PIC_OFFSET_TABLE_REGNUM);
+ return 0;
+ }
+#endif
+ if (GET_CODE (x) == SUBREG)
+ x = SUBREG_REG (x);
+ if (REG_P (x))
+ {
+ srcregno = REGNO (x);
+ SET_BIT (reg_inheritance_matrix[dstregno], srcregno);
+ }
+ if (GET_CODE (x) == CONST_VECTOR)
+ {
+ SET_BIT (reg_inheritance_matrix[dstregno], PIC_OFFSET_TABLE_REGNUM);
+ }
+ return 0; /* Keep walking the RTX; visit all the REGs. */
+}
+/* Walk all the insns and set the reg_inheritance_matrix[]. */
+void
+reg_inheritance (void)
+{
+ unsigned int /* dstregno, */ pic_rtx_regno, ui;
+ /* int i; */
+ /* rtx dst, insn, set, src; */
+ bool changing;
+
+ if (!optimize)
+ return;
+
+ if (pic_rtx_inheritance)
+ sbitmap_free (pic_rtx_inheritance);
+ pic_rtx_inheritance = sbitmap_alloc (max_regno);
+ sbitmap_zero (pic_rtx_inheritance);
+ pic_rtx_regno = PIC_OFFSET_TABLE_REGNUM;
+ /* Now loop over reg_inheritance_matrix[], computing pic_rtx_inheritance. */
+ for (ui = FIRST_PSEUDO_REGISTER; ui < (unsigned)max_regno; ui++)
+ {
+ /* This row of the matrix represents the regnos (pseudo and
+ hard) that are inherited by pseudo regno ui. If regno ui
+ inherits from the PIC_OFFSET_TABLE_REGNUM, set the ui bit in
+ pic_rtx_inheritance. */
+ if (TEST_BIT (reg_inheritance_matrix[ui], pic_rtx_regno))
+ SET_BIT (pic_rtx_inheritance, ui);
+ /* else AND pic_rtx_inheritance with reg_inheritance_matrix[ui *
+ max_regno_row_words + (PIC_OFFSET_TABLE_REGNUM / INT_BITS)],
+ if nonzero, set the same bit */
+ }
+ /* pic_rtx_inheritance has a bit set for every pseudo that inherits
+ the PIC_OFFSET_TABLE_REGNUM directly. Now compute all the pseudo
+ registers that inherit PIC_OFFSET_TABLE_REGNUM indirectly. */
+ /* now, indefinite loop over reg_inheritance_matrix[], ANDing with each entry;
+ when non-zero, OR in bit as above.
+ continue until no more change observed */
+ /* FIXME: obvious candidate for sbitmap.h:EXECUTE_IF_SET_IN_SBITMAP() */
+ do {
+ changing = false;
+ for (ui = FIRST_PSEUDO_REGISTER; ui < (unsigned)max_regno; ui++)
+ if (!TEST_BIT (pic_rtx_inheritance, ui)
+ && sbitmap_any_common_bits (reg_inheritance_matrix[ui], pic_rtx_inheritance))
+ {
+ SET_BIT (pic_rtx_inheritance, ui);
+ changing = true;
+ }
+ } while (changing);
+ if (dump_file)
+ {
+ timevar_push (TV_DUMP);
+ dump_inheritance (dump_file);
+ timevar_pop (TV_DUMP);
+ }
+}
+/* APPLE LOCAL end 5695218 */
+
/* LLVM LOCAL begin */
#endif
/* LLVM LOCAL end */
Modified: llvm-gcc-4.2/trunk/gcc/tree-pass.h
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/gcc/tree-pass.h?rev=54192&r1=54191&r2=54192&view=diff
==============================================================================
--- llvm-gcc-4.2/trunk/gcc/tree-pass.h (original)
+++ llvm-gcc-4.2/trunk/gcc/tree-pass.h Tue Jul 29 22:35:16 2008
@@ -360,6 +360,9 @@
extern struct tree_opt_pass pass_recompute_reg_usage;
extern struct tree_opt_pass pass_sms;
extern struct tree_opt_pass pass_sched;
+/* APPLE LOCAL begin 5695218 */
+extern struct tree_opt_pass pass_life3;
+/* APPLE LOCAL end 5695218 */
extern struct tree_opt_pass pass_local_alloc;
extern struct tree_opt_pass pass_global_alloc;
extern struct tree_opt_pass pass_postreload;
More information about the llvm-commits
mailing list