Merge branch 'vendor/GCC50' - gcc 5.0 snapshot 1 FEB 2015
[dragonfly.git] / contrib / gcc-5.0 / gcc / config / i386 / i386.h
1 /* Definitions of target machine for GCC for IA-32.
2    Copyright (C) 1988-2015 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC 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 3, or (at your option)
9 any later version.
10
11 GCC 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 Under Section 7 of GPL version 3, you are granted additional
17 permissions described in the GCC Runtime Library Exception, version
18 3.1, as published by the Free Software Foundation.
19
20 You should have received a copy of the GNU General Public License and
21 a copy of the GCC Runtime Library Exception along with this program;
22 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23 <http://www.gnu.org/licenses/>.  */
24
25 /* The purpose of this file is to define the characteristics of the i386,
26    independent of assembler syntax or operating system.
27
28    Three other files build on this one to describe a specific assembler syntax:
29    bsd386.h, att386.h, and sun386.h.
30
31    The actual tm.h file for a particular system should include
32    this file, and then the file for the appropriate assembler syntax.
33
34    Many macros that specify assembler syntax are omitted entirely from
35    this file because they really belong in the files for particular
36    assemblers.  These include RP, IP, LPREFIX, PUT_OP_SIZE, USE_STAR,
37    ADDR_BEG, ADDR_END, PRINT_IREG, PRINT_SCALE, PRINT_B_I_S, and many
38    that start with ASM_ or end in ASM_OP.  */
39
40 /* Redefines for option macros.  */
41
42 #define TARGET_64BIT    TARGET_ISA_64BIT
43 #define TARGET_64BIT_P(x)       TARGET_ISA_64BIT_P(x)
44 #define TARGET_MMX      TARGET_ISA_MMX
45 #define TARGET_MMX_P(x) TARGET_ISA_MMX_P(x)
46 #define TARGET_3DNOW    TARGET_ISA_3DNOW
47 #define TARGET_3DNOW_P(x)       TARGET_ISA_3DNOW_P(x)
48 #define TARGET_3DNOW_A  TARGET_ISA_3DNOW_A
49 #define TARGET_3DNOW_A_P(x)     TARGET_ISA_3DNOW_A_P(x)
50 #define TARGET_SSE      TARGET_ISA_SSE
51 #define TARGET_SSE_P(x) TARGET_ISA_SSE_P(x)
52 #define TARGET_SSE2     TARGET_ISA_SSE2
53 #define TARGET_SSE2_P(x)        TARGET_ISA_SSE2_P(x)
54 #define TARGET_SSE3     TARGET_ISA_SSE3
55 #define TARGET_SSE3_P(x)        TARGET_ISA_SSE3_P(x)
56 #define TARGET_SSSE3    TARGET_ISA_SSSE3
57 #define TARGET_SSSE3_P(x)       TARGET_ISA_SSSE3_P(x)
58 #define TARGET_SSE4_1   TARGET_ISA_SSE4_1
59 #define TARGET_SSE4_1_P(x)      TARGET_ISA_SSE4_1_P(x)
60 #define TARGET_SSE4_2   TARGET_ISA_SSE4_2
61 #define TARGET_SSE4_2_P(x)      TARGET_ISA_SSE4_2_P(x)
62 #define TARGET_AVX      TARGET_ISA_AVX
63 #define TARGET_AVX_P(x) TARGET_ISA_AVX_P(x)
64 #define TARGET_AVX2     TARGET_ISA_AVX2
65 #define TARGET_AVX2_P(x)        TARGET_ISA_AVX2_P(x)
66 #define TARGET_AVX512F  TARGET_ISA_AVX512F
67 #define TARGET_AVX512F_P(x)     TARGET_ISA_AVX512F_P(x)
68 #define TARGET_AVX512PF TARGET_ISA_AVX512PF
69 #define TARGET_AVX512PF_P(x)    TARGET_ISA_AVX512PF_P(x)
70 #define TARGET_AVX512ER TARGET_ISA_AVX512ER
71 #define TARGET_AVX512ER_P(x)    TARGET_ISA_AVX512ER_P(x)
72 #define TARGET_AVX512CD TARGET_ISA_AVX512CD
73 #define TARGET_AVX512CD_P(x)    TARGET_ISA_AVX512CD_P(x)
74 #define TARGET_AVX512DQ TARGET_ISA_AVX512DQ
75 #define TARGET_AVX512DQ_P(x)    TARGET_ISA_AVX512DQ_P(x)
76 #define TARGET_AVX512BW TARGET_ISA_AVX512BW
77 #define TARGET_AVX512BW_P(x)    TARGET_ISA_AVX512BW_P(x)
78 #define TARGET_AVX512VL TARGET_ISA_AVX512VL
79 #define TARGET_AVX512VL_P(x)    TARGET_ISA_AVX512VL_P(x)
80 #define TARGET_AVX512VBMI       TARGET_ISA_AVX512VBMI
81 #define TARGET_AVX512VBMI_P(x)  TARGET_ISA_AVX512VBMI_P(x)
82 #define TARGET_AVX512IFMA       TARGET_ISA_AVX512IFMA
83 #define TARGET_AVX512IFMA_P(x)  TARGET_ISA_AVX512IFMA_P(x)
84 #define TARGET_FMA      TARGET_ISA_FMA
85 #define TARGET_FMA_P(x) TARGET_ISA_FMA_P(x)
86 #define TARGET_SSE4A    TARGET_ISA_SSE4A
87 #define TARGET_SSE4A_P(x)       TARGET_ISA_SSE4A_P(x)
88 #define TARGET_FMA4     TARGET_ISA_FMA4
89 #define TARGET_FMA4_P(x)        TARGET_ISA_FMA4_P(x)
90 #define TARGET_XOP      TARGET_ISA_XOP
91 #define TARGET_XOP_P(x) TARGET_ISA_XOP_P(x)
92 #define TARGET_LWP      TARGET_ISA_LWP
93 #define TARGET_LWP_P(x) TARGET_ISA_LWP_P(x)
94 #define TARGET_ROUND    TARGET_ISA_ROUND
95 #define TARGET_ABM      TARGET_ISA_ABM
96 #define TARGET_ABM_P(x) TARGET_ISA_ABM_P(x)
97 #define TARGET_BMI      TARGET_ISA_BMI
98 #define TARGET_BMI_P(x) TARGET_ISA_BMI_P(x)
99 #define TARGET_BMI2     TARGET_ISA_BMI2
100 #define TARGET_BMI2_P(x)        TARGET_ISA_BMI2_P(x)
101 #define TARGET_LZCNT    TARGET_ISA_LZCNT
102 #define TARGET_LZCNT_P(x)       TARGET_ISA_LZCNT_P(x)
103 #define TARGET_TBM      TARGET_ISA_TBM
104 #define TARGET_TBM_P(x) TARGET_ISA_TBM_P(x)
105 #define TARGET_POPCNT   TARGET_ISA_POPCNT
106 #define TARGET_POPCNT_P(x)      TARGET_ISA_POPCNT_P(x)
107 #define TARGET_SAHF     TARGET_ISA_SAHF
108 #define TARGET_SAHF_P(x)        TARGET_ISA_SAHF_P(x)
109 #define TARGET_MOVBE    TARGET_ISA_MOVBE
110 #define TARGET_MOVBE_P(x)       TARGET_ISA_MOVBE_P(x)
111 #define TARGET_CRC32    TARGET_ISA_CRC32
112 #define TARGET_CRC32_P(x)       TARGET_ISA_CRC32_P(x)
113 #define TARGET_AES      TARGET_ISA_AES
114 #define TARGET_AES_P(x) TARGET_ISA_AES_P(x)
115 #define TARGET_SHA      TARGET_ISA_SHA
116 #define TARGET_SHA_P(x) TARGET_ISA_SHA_P(x)
117 #define TARGET_CLFLUSHOPT       TARGET_ISA_CLFLUSHOPT
118 #define TARGET_CLFLUSHOPT_P(x)  TARGET_ISA_CLFLUSHOPT_P(x)
119 #define TARGET_XSAVEC   TARGET_ISA_XSAVEC
120 #define TARGET_XSAVEC_P(x)      TARGET_ISA_XSAVEC_P(x)
121 #define TARGET_XSAVES   TARGET_ISA_XSAVES
122 #define TARGET_XSAVES_P(x)      TARGET_ISA_XSAVES_P(x)
123 #define TARGET_PCLMUL   TARGET_ISA_PCLMUL
124 #define TARGET_PCLMUL_P(x)      TARGET_ISA_PCLMUL_P(x)
125 #define TARGET_CMPXCHG16B       TARGET_ISA_CX16
126 #define TARGET_CMPXCHG16B_P(x)  TARGET_ISA_CX16_P(x)
127 #define TARGET_FSGSBASE TARGET_ISA_FSGSBASE
128 #define TARGET_FSGSBASE_P(x)    TARGET_ISA_FSGSBASE_P(x)
129 #define TARGET_RDRND    TARGET_ISA_RDRND
130 #define TARGET_RDRND_P(x)       TARGET_ISA_RDRND_P(x)
131 #define TARGET_F16C     TARGET_ISA_F16C
132 #define TARGET_F16C_P(x)        TARGET_ISA_F16C_P(x)
133 #define TARGET_RTM      TARGET_ISA_RTM
134 #define TARGET_RTM_P(x) TARGET_ISA_RTM_P(x)
135 #define TARGET_HLE      TARGET_ISA_HLE
136 #define TARGET_HLE_P(x) TARGET_ISA_HLE_P(x)
137 #define TARGET_RDSEED   TARGET_ISA_RDSEED
138 #define TARGET_RDSEED_P(x)      TARGET_ISA_RDSEED_P(x)
139 #define TARGET_PRFCHW   TARGET_ISA_PRFCHW
140 #define TARGET_PRFCHW_P(x)      TARGET_ISA_PRFCHW_P(x)
141 #define TARGET_ADX      TARGET_ISA_ADX
142 #define TARGET_ADX_P(x) TARGET_ISA_ADX_P(x)
143 #define TARGET_FXSR     TARGET_ISA_FXSR
144 #define TARGET_FXSR_P(x)        TARGET_ISA_FXSR_P(x)
145 #define TARGET_XSAVE    TARGET_ISA_XSAVE
146 #define TARGET_XSAVE_P(x)       TARGET_ISA_XSAVE_P(x)
147 #define TARGET_XSAVEOPT TARGET_ISA_XSAVEOPT
148 #define TARGET_XSAVEOPT_P(x)    TARGET_ISA_XSAVEOPT_P(x)
149 #define TARGET_PREFETCHWT1      TARGET_ISA_PREFETCHWT1
150 #define TARGET_PREFETCHWT1_P(x) TARGET_ISA_PREFETCHWT1_P(x)
151 #define TARGET_MPX      TARGET_ISA_MPX
152 #define TARGET_MPX_P(x) TARGET_ISA_MPX_P(x)
153 #define TARGET_PCOMMIT  TARGET_ISA_PCOMMIT
154 #define TARGET_PCOMMIT_P(x)     TARGET_ISA_PCOMMIT_P(x)
155 #define TARGET_CLWB     TARGET_ISA_CLWB
156 #define TARGET_CLWB_P(x)        TARGET_ISA_CLWB_P(x)
157
158 #define TARGET_LP64     TARGET_ABI_64
159 #define TARGET_LP64_P(x)        TARGET_ABI_64_P(x)
160 #define TARGET_X32      TARGET_ABI_X32
161 #define TARGET_X32_P(x) TARGET_ABI_X32_P(x)
162 #define TARGET_16BIT    TARGET_CODE16
163 #define TARGET_16BIT_P(x)       TARGET_CODE16_P(x)
164
165 /* SSE4.1 defines round instructions */
166 #define OPTION_MASK_ISA_ROUND   OPTION_MASK_ISA_SSE4_1
167 #define TARGET_ISA_ROUND        ((ix86_isa_flags & OPTION_MASK_ISA_ROUND) != 0)
168
169 #include "config/vxworks-dummy.h"
170
171 #include "config/i386/i386-opts.h"
172
173 #define MAX_STRINGOP_ALGS 4
174
175 /* Specify what algorithm to use for stringops on known size.
176    When size is unknown, the UNKNOWN_SIZE alg is used.  When size is
177    known at compile time or estimated via feedback, the SIZE array
178    is walked in order until MAX is greater then the estimate (or -1
179    means infinity).  Corresponding ALG is used then.
180    When NOALIGN is true the code guaranting the alignment of the memory
181    block is skipped.
182
183    For example initializer:
184     {{256, loop}, {-1, rep_prefix_4_byte}}
185    will use loop for blocks smaller or equal to 256 bytes, rep prefix will
186    be used otherwise.  */
187 struct stringop_algs
188 {
189   const enum stringop_alg unknown_size;
190   const struct stringop_strategy {
191     const int max;
192     const enum stringop_alg alg;
193     int noalign;
194   } size [MAX_STRINGOP_ALGS];
195 };
196
197 /* Define the specific costs for a given cpu */
198
199 struct processor_costs {
200   const int add;                /* cost of an add instruction */
201   const int lea;                /* cost of a lea instruction */
202   const int shift_var;          /* variable shift costs */
203   const int shift_const;        /* constant shift costs */
204   const int mult_init[5];       /* cost of starting a multiply
205                                    in QImode, HImode, SImode, DImode, TImode*/
206   const int mult_bit;           /* cost of multiply per each bit set */
207   const int divide[5];          /* cost of a divide/mod
208                                    in QImode, HImode, SImode, DImode, TImode*/
209   int movsx;                    /* The cost of movsx operation.  */
210   int movzx;                    /* The cost of movzx operation.  */
211   const int large_insn;         /* insns larger than this cost more */
212   const int move_ratio;         /* The threshold of number of scalar
213                                    memory-to-memory move insns.  */
214   const int movzbl_load;        /* cost of loading using movzbl */
215   const int int_load[3];        /* cost of loading integer registers
216                                    in QImode, HImode and SImode relative
217                                    to reg-reg move (2).  */
218   const int int_store[3];       /* cost of storing integer register
219                                    in QImode, HImode and SImode */
220   const int fp_move;            /* cost of reg,reg fld/fst */
221   const int fp_load[3];         /* cost of loading FP register
222                                    in SFmode, DFmode and XFmode */
223   const int fp_store[3];        /* cost of storing FP register
224                                    in SFmode, DFmode and XFmode */
225   const int mmx_move;           /* cost of moving MMX register.  */
226   const int mmx_load[2];        /* cost of loading MMX register
227                                    in SImode and DImode */
228   const int mmx_store[2];       /* cost of storing MMX register
229                                    in SImode and DImode */
230   const int sse_move;           /* cost of moving SSE register.  */
231   const int sse_load[3];        /* cost of loading SSE register
232                                    in SImode, DImode and TImode*/
233   const int sse_store[3];       /* cost of storing SSE register
234                                    in SImode, DImode and TImode*/
235   const int mmxsse_to_integer;  /* cost of moving mmxsse register to
236                                    integer and vice versa.  */
237   const int l1_cache_size;      /* size of l1 cache, in kilobytes.  */
238   const int l2_cache_size;      /* size of l2 cache, in kilobytes.  */
239   const int prefetch_block;     /* bytes moved to cache for prefetch.  */
240   const int simultaneous_prefetches; /* number of parallel prefetch
241                                    operations.  */
242   const int branch_cost;        /* Default value for BRANCH_COST.  */
243   const int fadd;               /* cost of FADD and FSUB instructions.  */
244   const int fmul;               /* cost of FMUL instruction.  */
245   const int fdiv;               /* cost of FDIV instruction.  */
246   const int fabs;               /* cost of FABS instruction.  */
247   const int fchs;               /* cost of FCHS instruction.  */
248   const int fsqrt;              /* cost of FSQRT instruction.  */
249                                 /* Specify what algorithm
250                                    to use for stringops on unknown size.  */
251   struct stringop_algs *memcpy, *memset;
252   const int scalar_stmt_cost;   /* Cost of any scalar operation, excluding
253                                    load and store.  */
254   const int scalar_load_cost;   /* Cost of scalar load.  */
255   const int scalar_store_cost;  /* Cost of scalar store.  */
256   const int vec_stmt_cost;      /* Cost of any vector operation, excluding
257                                    load, store, vector-to-scalar and
258                                    scalar-to-vector operation.  */
259   const int vec_to_scalar_cost;    /* Cost of vect-to-scalar operation.  */
260   const int scalar_to_vec_cost;    /* Cost of scalar-to-vector operation.  */
261   const int vec_align_load_cost;   /* Cost of aligned vector load.  */
262   const int vec_unalign_load_cost; /* Cost of unaligned vector load.  */
263   const int vec_store_cost;        /* Cost of vector store.  */
264   const int cond_taken_branch_cost;    /* Cost of taken branch for vectorizer
265                                           cost model.  */
266   const int cond_not_taken_branch_cost;/* Cost of not taken branch for
267                                           vectorizer cost model.  */
268 };
269
270 extern const struct processor_costs *ix86_cost;
271 extern const struct processor_costs ix86_size_cost;
272
273 #define ix86_cur_cost() \
274   (optimize_insn_for_size_p () ? &ix86_size_cost: ix86_cost)
275
276 /* Macros used in the machine description to test the flags.  */
277
278 /* configure can arrange to change it.  */
279
280 #ifndef TARGET_CPU_DEFAULT
281 #define TARGET_CPU_DEFAULT PROCESSOR_GENERIC
282 #endif
283
284 #ifndef TARGET_FPMATH_DEFAULT
285 #define TARGET_FPMATH_DEFAULT \
286   (TARGET_64BIT && TARGET_SSE ? FPMATH_SSE : FPMATH_387)
287 #endif
288
289 #ifndef TARGET_FPMATH_DEFAULT_P
290 #define TARGET_FPMATH_DEFAULT_P(x) \
291   (TARGET_64BIT_P(x) && TARGET_SSE_P(x) ? FPMATH_SSE : FPMATH_387)
292 #endif
293
294 #define TARGET_FLOAT_RETURNS_IN_80387 TARGET_FLOAT_RETURNS
295 #define TARGET_FLOAT_RETURNS_IN_80387_P(x) TARGET_FLOAT_RETURNS_P(x)
296
297 /* 64bit Sledgehammer mode.  For libgcc2 we make sure this is a
298    compile-time constant.  */
299 #ifdef IN_LIBGCC2
300 #undef TARGET_64BIT
301 #ifdef __x86_64__
302 #define TARGET_64BIT 1
303 #else
304 #define TARGET_64BIT 0
305 #endif
306 #else
307 #ifndef TARGET_BI_ARCH
308 #undef TARGET_64BIT
309 #undef TARGET_64BIT_P
310 #if TARGET_64BIT_DEFAULT
311 #define TARGET_64BIT 1
312 #define TARGET_64BIT_P(x) 1
313 #else
314 #define TARGET_64BIT 0
315 #define TARGET_64BIT_P(x) 0
316 #endif
317 #endif
318 #endif
319
320 #define HAS_LONG_COND_BRANCH 1
321 #define HAS_LONG_UNCOND_BRANCH 1
322
323 #define TARGET_386 (ix86_tune == PROCESSOR_I386)
324 #define TARGET_486 (ix86_tune == PROCESSOR_I486)
325 #define TARGET_PENTIUM (ix86_tune == PROCESSOR_PENTIUM)
326 #define TARGET_PENTIUMPRO (ix86_tune == PROCESSOR_PENTIUMPRO)
327 #define TARGET_GEODE (ix86_tune == PROCESSOR_GEODE)
328 #define TARGET_K6 (ix86_tune == PROCESSOR_K6)
329 #define TARGET_ATHLON (ix86_tune == PROCESSOR_ATHLON)
330 #define TARGET_PENTIUM4 (ix86_tune == PROCESSOR_PENTIUM4)
331 #define TARGET_K8 (ix86_tune == PROCESSOR_K8)
332 #define TARGET_ATHLON_K8 (TARGET_K8 || TARGET_ATHLON)
333 #define TARGET_NOCONA (ix86_tune == PROCESSOR_NOCONA)
334 #define TARGET_CORE2 (ix86_tune == PROCESSOR_CORE2)
335 #define TARGET_NEHALEM (ix86_tune == PROCESSOR_NEHALEM)
336 #define TARGET_SANDYBRIDGE (ix86_tune == PROCESSOR_SANDYBRIDGE)
337 #define TARGET_HASWELL (ix86_tune == PROCESSOR_HASWELL)
338 #define TARGET_BONNELL (ix86_tune == PROCESSOR_BONNELL)
339 #define TARGET_SILVERMONT (ix86_tune == PROCESSOR_SILVERMONT)
340 #define TARGET_KNL (ix86_tune == PROCESSOR_KNL)
341 #define TARGET_INTEL (ix86_tune == PROCESSOR_INTEL)
342 #define TARGET_GENERIC (ix86_tune == PROCESSOR_GENERIC)
343 #define TARGET_AMDFAM10 (ix86_tune == PROCESSOR_AMDFAM10)
344 #define TARGET_BDVER1 (ix86_tune == PROCESSOR_BDVER1)
345 #define TARGET_BDVER2 (ix86_tune == PROCESSOR_BDVER2)
346 #define TARGET_BDVER3 (ix86_tune == PROCESSOR_BDVER3)
347 #define TARGET_BDVER4 (ix86_tune == PROCESSOR_BDVER4)
348 #define TARGET_BTVER1 (ix86_tune == PROCESSOR_BTVER1)
349 #define TARGET_BTVER2 (ix86_tune == PROCESSOR_BTVER2)
350
351 /* Feature tests against the various tunings.  */
352 enum ix86_tune_indices {
353 #undef DEF_TUNE
354 #define DEF_TUNE(tune, name, selector) tune,
355 #include "x86-tune.def"
356 #undef DEF_TUNE
357 X86_TUNE_LAST
358 };
359
360 extern unsigned char ix86_tune_features[X86_TUNE_LAST];
361
362 #define TARGET_USE_LEAVE        ix86_tune_features[X86_TUNE_USE_LEAVE]
363 #define TARGET_PUSH_MEMORY      ix86_tune_features[X86_TUNE_PUSH_MEMORY]
364 #define TARGET_ZERO_EXTEND_WITH_AND \
365         ix86_tune_features[X86_TUNE_ZERO_EXTEND_WITH_AND]
366 #define TARGET_UNROLL_STRLEN    ix86_tune_features[X86_TUNE_UNROLL_STRLEN]
367 #define TARGET_BRANCH_PREDICTION_HINTS \
368         ix86_tune_features[X86_TUNE_BRANCH_PREDICTION_HINTS]
369 #define TARGET_DOUBLE_WITH_ADD  ix86_tune_features[X86_TUNE_DOUBLE_WITH_ADD]
370 #define TARGET_USE_SAHF         ix86_tune_features[X86_TUNE_USE_SAHF]
371 #define TARGET_MOVX             ix86_tune_features[X86_TUNE_MOVX]
372 #define TARGET_PARTIAL_REG_STALL ix86_tune_features[X86_TUNE_PARTIAL_REG_STALL]
373 #define TARGET_PARTIAL_FLAG_REG_STALL \
374         ix86_tune_features[X86_TUNE_PARTIAL_FLAG_REG_STALL]
375 #define TARGET_LCP_STALL \
376         ix86_tune_features[X86_TUNE_LCP_STALL]
377 #define TARGET_USE_HIMODE_FIOP  ix86_tune_features[X86_TUNE_USE_HIMODE_FIOP]
378 #define TARGET_USE_SIMODE_FIOP  ix86_tune_features[X86_TUNE_USE_SIMODE_FIOP]
379 #define TARGET_USE_MOV0         ix86_tune_features[X86_TUNE_USE_MOV0]
380 #define TARGET_USE_CLTD         ix86_tune_features[X86_TUNE_USE_CLTD]
381 #define TARGET_USE_XCHGB        ix86_tune_features[X86_TUNE_USE_XCHGB]
382 #define TARGET_SPLIT_LONG_MOVES ix86_tune_features[X86_TUNE_SPLIT_LONG_MOVES]
383 #define TARGET_READ_MODIFY_WRITE ix86_tune_features[X86_TUNE_READ_MODIFY_WRITE]
384 #define TARGET_READ_MODIFY      ix86_tune_features[X86_TUNE_READ_MODIFY]
385 #define TARGET_PROMOTE_QImode   ix86_tune_features[X86_TUNE_PROMOTE_QIMODE]
386 #define TARGET_FAST_PREFIX      ix86_tune_features[X86_TUNE_FAST_PREFIX]
387 #define TARGET_SINGLE_STRINGOP  ix86_tune_features[X86_TUNE_SINGLE_STRINGOP]
388 #define TARGET_MISALIGNED_MOVE_STRING_PRO_EPILOGUES \
389         ix86_tune_features[X86_TUNE_MISALIGNED_MOVE_STRING_PRO_EPILOGUES]
390 #define TARGET_QIMODE_MATH      ix86_tune_features[X86_TUNE_QIMODE_MATH]
391 #define TARGET_HIMODE_MATH      ix86_tune_features[X86_TUNE_HIMODE_MATH]
392 #define TARGET_PROMOTE_QI_REGS  ix86_tune_features[X86_TUNE_PROMOTE_QI_REGS]
393 #define TARGET_PROMOTE_HI_REGS  ix86_tune_features[X86_TUNE_PROMOTE_HI_REGS]
394 #define TARGET_SINGLE_POP       ix86_tune_features[X86_TUNE_SINGLE_POP]
395 #define TARGET_DOUBLE_POP       ix86_tune_features[X86_TUNE_DOUBLE_POP]
396 #define TARGET_SINGLE_PUSH      ix86_tune_features[X86_TUNE_SINGLE_PUSH]
397 #define TARGET_DOUBLE_PUSH      ix86_tune_features[X86_TUNE_DOUBLE_PUSH]
398 #define TARGET_INTEGER_DFMODE_MOVES \
399         ix86_tune_features[X86_TUNE_INTEGER_DFMODE_MOVES]
400 #define TARGET_PARTIAL_REG_DEPENDENCY \
401         ix86_tune_features[X86_TUNE_PARTIAL_REG_DEPENDENCY]
402 #define TARGET_SSE_PARTIAL_REG_DEPENDENCY \
403         ix86_tune_features[X86_TUNE_SSE_PARTIAL_REG_DEPENDENCY]
404 #define TARGET_SSE_UNALIGNED_LOAD_OPTIMAL \
405         ix86_tune_features[X86_TUNE_SSE_UNALIGNED_LOAD_OPTIMAL]
406 #define TARGET_SSE_UNALIGNED_STORE_OPTIMAL \
407         ix86_tune_features[X86_TUNE_SSE_UNALIGNED_STORE_OPTIMAL]
408 #define TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL \
409         ix86_tune_features[X86_TUNE_SSE_PACKED_SINGLE_INSN_OPTIMAL]
410 #define TARGET_SSE_SPLIT_REGS   ix86_tune_features[X86_TUNE_SSE_SPLIT_REGS]
411 #define TARGET_SSE_TYPELESS_STORES \
412         ix86_tune_features[X86_TUNE_SSE_TYPELESS_STORES]
413 #define TARGET_SSE_LOAD0_BY_PXOR ix86_tune_features[X86_TUNE_SSE_LOAD0_BY_PXOR]
414 #define TARGET_MEMORY_MISMATCH_STALL \
415         ix86_tune_features[X86_TUNE_MEMORY_MISMATCH_STALL]
416 #define TARGET_PROLOGUE_USING_MOVE \
417         ix86_tune_features[X86_TUNE_PROLOGUE_USING_MOVE]
418 #define TARGET_EPILOGUE_USING_MOVE \
419         ix86_tune_features[X86_TUNE_EPILOGUE_USING_MOVE]
420 #define TARGET_SHIFT1           ix86_tune_features[X86_TUNE_SHIFT1]
421 #define TARGET_USE_FFREEP       ix86_tune_features[X86_TUNE_USE_FFREEP]
422 #define TARGET_INTER_UNIT_MOVES_TO_VEC \
423         ix86_tune_features[X86_TUNE_INTER_UNIT_MOVES_TO_VEC]
424 #define TARGET_INTER_UNIT_MOVES_FROM_VEC \
425         ix86_tune_features[X86_TUNE_INTER_UNIT_MOVES_FROM_VEC]
426 #define TARGET_INTER_UNIT_CONVERSIONS \
427         ix86_tune_features[X86_TUNE_INTER_UNIT_CONVERSIONS]
428 #define TARGET_FOUR_JUMP_LIMIT  ix86_tune_features[X86_TUNE_FOUR_JUMP_LIMIT]
429 #define TARGET_SCHEDULE         ix86_tune_features[X86_TUNE_SCHEDULE]
430 #define TARGET_USE_BT           ix86_tune_features[X86_TUNE_USE_BT]
431 #define TARGET_USE_INCDEC       ix86_tune_features[X86_TUNE_USE_INCDEC]
432 #define TARGET_PAD_RETURNS      ix86_tune_features[X86_TUNE_PAD_RETURNS]
433 #define TARGET_PAD_SHORT_FUNCTION \
434         ix86_tune_features[X86_TUNE_PAD_SHORT_FUNCTION]
435 #define TARGET_EXT_80387_CONSTANTS \
436         ix86_tune_features[X86_TUNE_EXT_80387_CONSTANTS]
437 #define TARGET_AVOID_VECTOR_DECODE \
438         ix86_tune_features[X86_TUNE_AVOID_VECTOR_DECODE]
439 #define TARGET_TUNE_PROMOTE_HIMODE_IMUL \
440         ix86_tune_features[X86_TUNE_PROMOTE_HIMODE_IMUL]
441 #define TARGET_SLOW_IMUL_IMM32_MEM \
442         ix86_tune_features[X86_TUNE_SLOW_IMUL_IMM32_MEM]
443 #define TARGET_SLOW_IMUL_IMM8   ix86_tune_features[X86_TUNE_SLOW_IMUL_IMM8]
444 #define TARGET_MOVE_M1_VIA_OR   ix86_tune_features[X86_TUNE_MOVE_M1_VIA_OR]
445 #define TARGET_NOT_UNPAIRABLE   ix86_tune_features[X86_TUNE_NOT_UNPAIRABLE]
446 #define TARGET_NOT_VECTORMODE   ix86_tune_features[X86_TUNE_NOT_VECTORMODE]
447 #define TARGET_USE_VECTOR_FP_CONVERTS \
448         ix86_tune_features[X86_TUNE_USE_VECTOR_FP_CONVERTS]
449 #define TARGET_USE_VECTOR_CONVERTS \
450         ix86_tune_features[X86_TUNE_USE_VECTOR_CONVERTS]
451 #define TARGET_SLOW_PSHUFB \
452         ix86_tune_features[X86_TUNE_SLOW_PSHUFB]
453 #define TARGET_VECTOR_PARALLEL_EXECUTION \
454         ix86_tune_features[X86_TUNE_VECTOR_PARALLEL_EXECUTION]
455 #define TARGET_FUSE_CMP_AND_BRANCH_32 \
456         ix86_tune_features[X86_TUNE_FUSE_CMP_AND_BRANCH_32]
457 #define TARGET_FUSE_CMP_AND_BRANCH_64 \
458         ix86_tune_features[X86_TUNE_FUSE_CMP_AND_BRANCH_64]
459 #define TARGET_FUSE_CMP_AND_BRANCH \
460         (TARGET_64BIT ? TARGET_FUSE_CMP_AND_BRANCH_64 \
461          : TARGET_FUSE_CMP_AND_BRANCH_32)
462 #define TARGET_FUSE_CMP_AND_BRANCH_SOFLAGS \
463         ix86_tune_features[X86_TUNE_FUSE_CMP_AND_BRANCH_SOFLAGS]
464 #define TARGET_FUSE_ALU_AND_BRANCH \
465         ix86_tune_features[X86_TUNE_FUSE_ALU_AND_BRANCH]
466 #define TARGET_OPT_AGU ix86_tune_features[X86_TUNE_OPT_AGU]
467 #define TARGET_AVOID_LEA_FOR_ADDR \
468         ix86_tune_features[X86_TUNE_AVOID_LEA_FOR_ADDR]
469 #define TARGET_VECTORIZE_DOUBLE \
470         ix86_tune_features[X86_TUNE_VECTORIZE_DOUBLE]
471 #define TARGET_SOFTWARE_PREFETCHING_BENEFICIAL \
472         ix86_tune_features[X86_TUNE_SOFTWARE_PREFETCHING_BENEFICIAL]
473 #define TARGET_AVX128_OPTIMAL \
474         ix86_tune_features[X86_TUNE_AVX128_OPTIMAL]
475 #define TARGET_REASSOC_INT_TO_PARALLEL \
476         ix86_tune_features[X86_TUNE_REASSOC_INT_TO_PARALLEL]
477 #define TARGET_REASSOC_FP_TO_PARALLEL \
478         ix86_tune_features[X86_TUNE_REASSOC_FP_TO_PARALLEL]
479 #define TARGET_GENERAL_REGS_SSE_SPILL \
480         ix86_tune_features[X86_TUNE_GENERAL_REGS_SSE_SPILL]
481 #define TARGET_AVOID_MEM_OPND_FOR_CMOVE \
482         ix86_tune_features[X86_TUNE_AVOID_MEM_OPND_FOR_CMOVE]
483 #define TARGET_SPLIT_MEM_OPND_FOR_FP_CONVERTS \
484         ix86_tune_features[X86_TUNE_SPLIT_MEM_OPND_FOR_FP_CONVERTS]
485 #define TARGET_ADJUST_UNROLL \
486     ix86_tune_features[X86_TUNE_ADJUST_UNROLL]
487 #define TARGET_AVOID_FALSE_DEP_FOR_BMI \
488         ix86_tune_features[X86_TUNE_AVOID_FALSE_DEP_FOR_BMI]
489
490 /* Feature tests against the various architecture variations.  */
491 enum ix86_arch_indices {
492   X86_ARCH_CMOV,
493   X86_ARCH_CMPXCHG,
494   X86_ARCH_CMPXCHG8B,
495   X86_ARCH_XADD,
496   X86_ARCH_BSWAP,
497
498   X86_ARCH_LAST
499 };
500
501 extern unsigned char ix86_arch_features[X86_ARCH_LAST];
502
503 #define TARGET_CMOV             ix86_arch_features[X86_ARCH_CMOV]
504 #define TARGET_CMPXCHG          ix86_arch_features[X86_ARCH_CMPXCHG]
505 #define TARGET_CMPXCHG8B        ix86_arch_features[X86_ARCH_CMPXCHG8B]
506 #define TARGET_XADD             ix86_arch_features[X86_ARCH_XADD]
507 #define TARGET_BSWAP            ix86_arch_features[X86_ARCH_BSWAP]
508
509 /* For sane SSE instruction set generation we need fcomi instruction.
510    It is safe to enable all CMOVE instructions.  Also, RDRAND intrinsic
511    expands to a sequence that includes conditional move. */
512 #define TARGET_CMOVE            (TARGET_CMOV || TARGET_SSE || TARGET_RDRND)
513
514 #define TARGET_FISTTP           (TARGET_SSE3 && TARGET_80387)
515
516 extern unsigned char x86_prefetch_sse;
517 #define TARGET_PREFETCH_SSE     x86_prefetch_sse
518
519 #define ASSEMBLER_DIALECT       (ix86_asm_dialect)
520
521 #define TARGET_SSE_MATH         ((ix86_fpmath & FPMATH_SSE) != 0)
522 #define TARGET_MIX_SSE_I387 \
523  ((ix86_fpmath & (FPMATH_SSE | FPMATH_387)) == (FPMATH_SSE | FPMATH_387))
524
525 #define TARGET_GNU_TLS          (ix86_tls_dialect == TLS_DIALECT_GNU)
526 #define TARGET_GNU2_TLS         (ix86_tls_dialect == TLS_DIALECT_GNU2)
527 #define TARGET_ANY_GNU_TLS      (TARGET_GNU_TLS || TARGET_GNU2_TLS)
528 #define TARGET_SUN_TLS          0
529
530 #ifndef TARGET_64BIT_DEFAULT
531 #define TARGET_64BIT_DEFAULT 0
532 #endif
533 #ifndef TARGET_TLS_DIRECT_SEG_REFS_DEFAULT
534 #define TARGET_TLS_DIRECT_SEG_REFS_DEFAULT 0
535 #endif
536
537 #define TARGET_SSP_GLOBAL_GUARD (ix86_stack_protector_guard == SSP_GLOBAL)
538 #define TARGET_SSP_TLS_GUARD    (ix86_stack_protector_guard == SSP_TLS)
539
540 /* Fence to use after loop using storent.  */
541
542 extern tree x86_mfence;
543 #define FENCE_FOLLOWING_MOVNT x86_mfence
544
545 /* Once GDB has been enhanced to deal with functions without frame
546    pointers, we can change this to allow for elimination of
547    the frame pointer in leaf functions.  */
548 #define TARGET_DEFAULT 0
549
550 /* Extra bits to force.  */
551 #define TARGET_SUBTARGET_DEFAULT 0
552 #define TARGET_SUBTARGET_ISA_DEFAULT 0
553
554 /* Extra bits to force on w/ 32-bit mode.  */
555 #define TARGET_SUBTARGET32_DEFAULT 0
556 #define TARGET_SUBTARGET32_ISA_DEFAULT 0
557
558 /* Extra bits to force on w/ 64-bit mode.  */
559 #define TARGET_SUBTARGET64_DEFAULT 0
560 #define TARGET_SUBTARGET64_ISA_DEFAULT 0
561
562 /* Replace MACH-O, ifdefs by in-line tests, where possible. 
563    (a) Macros defined in config/i386/darwin.h  */
564 #define TARGET_MACHO 0
565 #define TARGET_MACHO_BRANCH_ISLANDS 0
566 #define MACHOPIC_ATT_STUB 0
567 /* (b) Macros defined in config/darwin.h  */
568 #define MACHO_DYNAMIC_NO_PIC_P 0
569 #define MACHOPIC_INDIRECT 0
570 #define MACHOPIC_PURE 0
571
572 /* For the RDOS  */
573 #define TARGET_RDOS 0
574
575 /* For the Windows 64-bit ABI.  */
576 #define TARGET_64BIT_MS_ABI (TARGET_64BIT && ix86_cfun_abi () == MS_ABI)
577
578 /* For the Windows 32-bit ABI.  */
579 #define TARGET_32BIT_MS_ABI (!TARGET_64BIT && ix86_cfun_abi () == MS_ABI)
580
581 /* This is re-defined by cygming.h.  */
582 #define TARGET_SEH 0
583
584 /* This is re-defined by cygming.h.  */
585 #define TARGET_PECOFF 0
586
587 /* The default abi used by target.  */
588 #define DEFAULT_ABI SYSV_ABI
589
590 /* The default TLS segment register used by target.  */
591 #define DEFAULT_TLS_SEG_REG (TARGET_64BIT ? SEG_FS : SEG_GS)
592
593 /* Subtargets may reset this to 1 in order to enable 96-bit long double
594    with the rounding mode forced to 53 bits.  */
595 #define TARGET_96_ROUND_53_LONG_DOUBLE 0
596
597 /* -march=native handling only makes sense with compiler running on
598    an x86 or x86_64 chip.  If changing this condition, also change
599    the condition in driver-i386.c.  */
600 #if defined(__i386__) || defined(__x86_64__)
601 /* In driver-i386.c.  */
602 extern const char *host_detect_local_cpu (int argc, const char **argv);
603 #define EXTRA_SPEC_FUNCTIONS \
604   { "local_cpu_detect", host_detect_local_cpu },
605 #define HAVE_LOCAL_CPU_DETECT
606 #endif
607
608 #if TARGET_64BIT_DEFAULT
609 #define OPT_ARCH64 "!m32"
610 #define OPT_ARCH32 "m32"
611 #else
612 #define OPT_ARCH64 "m64|mx32"
613 #define OPT_ARCH32 "m64|mx32:;"
614 #endif
615
616 /* Support for configure-time defaults of some command line options.
617    The order here is important so that -march doesn't squash the
618    tune or cpu values.  */
619 #define OPTION_DEFAULT_SPECS                                       \
620   {"tune", "%{!mtune=*:%{!mcpu=*:%{!march=*:-mtune=%(VALUE)}}}" }, \
621   {"tune_32", "%{" OPT_ARCH32 ":%{!mtune=*:%{!mcpu=*:%{!march=*:-mtune=%(VALUE)}}}}" }, \
622   {"tune_64", "%{" OPT_ARCH64 ":%{!mtune=*:%{!mcpu=*:%{!march=*:-mtune=%(VALUE)}}}}" }, \
623   {"cpu", "%{!mtune=*:%{!mcpu=*:%{!march=*:-mtune=%(VALUE)}}}" },  \
624   {"cpu_32", "%{" OPT_ARCH32 ":%{!mtune=*:%{!mcpu=*:%{!march=*:-mtune=%(VALUE)}}}}" }, \
625   {"cpu_64", "%{" OPT_ARCH64 ":%{!mtune=*:%{!mcpu=*:%{!march=*:-mtune=%(VALUE)}}}}" }, \
626   {"arch", "%{!march=*:-march=%(VALUE)}"},                         \
627   {"arch_32", "%{" OPT_ARCH32 ":%{!march=*:-march=%(VALUE)}}"},    \
628   {"arch_64", "%{" OPT_ARCH64 ":%{!march=*:-march=%(VALUE)}}"},
629
630 /* Specs for the compiler proper */
631
632 #ifndef CC1_CPU_SPEC
633 #define CC1_CPU_SPEC_1 ""
634
635 #ifndef HAVE_LOCAL_CPU_DETECT
636 #define CC1_CPU_SPEC CC1_CPU_SPEC_1
637 #else
638 #define CC1_CPU_SPEC CC1_CPU_SPEC_1 \
639 "%{march=native:%>march=native %:local_cpu_detect(arch) \
640   %{!mtune=*:%>mtune=native %:local_cpu_detect(tune)}} \
641 %{mtune=native:%>mtune=native %:local_cpu_detect(tune)}"
642 #endif
643 #endif
644 \f
645 /* Target CPU builtins.  */
646 #define TARGET_CPU_CPP_BUILTINS() ix86_target_macros ()
647
648 /* Target Pragmas.  */
649 #define REGISTER_TARGET_PRAGMAS() ix86_register_pragmas ()
650
651 #ifndef CC1_SPEC
652 #define CC1_SPEC "%(cc1_cpu) "
653 #endif
654
655 /* This macro defines names of additional specifications to put in the
656    specs that can be used in various specifications like CC1_SPEC.  Its
657    definition is an initializer with a subgrouping for each command option.
658
659    Each subgrouping contains a string constant, that defines the
660    specification name, and a string constant that used by the GCC driver
661    program.
662
663    Do not define this macro if it does not need to do anything.  */
664
665 #ifndef SUBTARGET_EXTRA_SPECS
666 #define SUBTARGET_EXTRA_SPECS
667 #endif
668
669 #define EXTRA_SPECS                                                     \
670   { "cc1_cpu",  CC1_CPU_SPEC },                                         \
671   SUBTARGET_EXTRA_SPECS
672 \f
673
674 /* Set the value of FLT_EVAL_METHOD in float.h.  When using only the
675    FPU, assume that the fpcw is set to extended precision; when using
676    only SSE, rounding is correct; when using both SSE and the FPU,
677    the rounding precision is indeterminate, since either may be chosen
678    apparently at random.  */
679 #define TARGET_FLT_EVAL_METHOD \
680   (TARGET_MIX_SSE_I387 ? -1 : TARGET_SSE_MATH ? 0 : 2)
681
682 /* Whether to allow x87 floating-point arithmetic on MODE (one of
683    SFmode, DFmode and XFmode) in the current excess precision
684    configuration.  */
685 #define X87_ENABLE_ARITH(MODE) \
686   (flag_excess_precision == EXCESS_PRECISION_FAST || (MODE) == XFmode)
687
688 /* Likewise, whether to allow direct conversions from integer mode
689    IMODE (HImode, SImode or DImode) to MODE.  */
690 #define X87_ENABLE_FLOAT(MODE, IMODE)                   \
691   (flag_excess_precision == EXCESS_PRECISION_FAST       \
692    || (MODE) == XFmode                                  \
693    || ((MODE) == DFmode && (IMODE) == SImode)           \
694    || (IMODE) == HImode)
695
696 /* target machine storage layout */
697
698 #define SHORT_TYPE_SIZE 16
699 #define INT_TYPE_SIZE 32
700 #define LONG_TYPE_SIZE (TARGET_X32 ? 32 : BITS_PER_WORD)
701 #define POINTER_SIZE (TARGET_X32 ? 32 : BITS_PER_WORD)
702 #define LONG_LONG_TYPE_SIZE 64
703 #define FLOAT_TYPE_SIZE 32
704 #define DOUBLE_TYPE_SIZE 64
705 #define LONG_DOUBLE_TYPE_SIZE \
706   (TARGET_LONG_DOUBLE_64 ? 64 : (TARGET_LONG_DOUBLE_128 ? 128 : 80))
707
708 #define WIDEST_HARDWARE_FP_SIZE 80
709
710 #if defined (TARGET_BI_ARCH) || TARGET_64BIT_DEFAULT
711 #define MAX_BITS_PER_WORD 64
712 #else
713 #define MAX_BITS_PER_WORD 32
714 #endif
715
716 /* Define this if most significant byte of a word is the lowest numbered.  */
717 /* That is true on the 80386.  */
718
719 #define BITS_BIG_ENDIAN 0
720
721 /* Define this if most significant byte of a word is the lowest numbered.  */
722 /* That is not true on the 80386.  */
723 #define BYTES_BIG_ENDIAN 0
724
725 /* Define this if most significant word of a multiword number is the lowest
726    numbered.  */
727 /* Not true for 80386 */
728 #define WORDS_BIG_ENDIAN 0
729
730 /* Width of a word, in units (bytes).  */
731 #define UNITS_PER_WORD          (TARGET_64BIT ? 8 : 4)
732
733 #ifndef IN_LIBGCC2
734 #define MIN_UNITS_PER_WORD      4
735 #endif
736
737 /* Allocation boundary (in *bits*) for storing arguments in argument list.  */
738 #define PARM_BOUNDARY BITS_PER_WORD
739
740 /* Boundary (in *bits*) on which stack pointer should be aligned.  */
741 #define STACK_BOUNDARY \
742  (TARGET_64BIT && ix86_abi == MS_ABI ? 128 : BITS_PER_WORD)
743
744 /* Stack boundary of the main function guaranteed by OS.  */
745 #define MAIN_STACK_BOUNDARY (TARGET_64BIT ? 128 : 32)
746
747 /* Minimum stack boundary.  */
748 #define MIN_STACK_BOUNDARY (TARGET_64BIT ? (TARGET_SSE ? 128 : 64) : 32)
749
750 /* Boundary (in *bits*) on which the stack pointer prefers to be
751    aligned; the compiler cannot rely on having this alignment.  */
752 #define PREFERRED_STACK_BOUNDARY ix86_preferred_stack_boundary
753
754 /* It should be MIN_STACK_BOUNDARY.  But we set it to 128 bits for
755    both 32bit and 64bit, to support codes that need 128 bit stack
756    alignment for SSE instructions, but can't realign the stack.  */
757 #define PREFERRED_STACK_BOUNDARY_DEFAULT 128
758
759 /* 1 if -mstackrealign should be turned on by default.  It will
760    generate an alternate prologue and epilogue that realigns the
761    runtime stack if nessary.  This supports mixing codes that keep a
762    4-byte aligned stack, as specified by i386 psABI, with codes that
763    need a 16-byte aligned stack, as required by SSE instructions.  */
764 #define STACK_REALIGN_DEFAULT 0
765
766 /* Boundary (in *bits*) on which the incoming stack is aligned.  */
767 #define INCOMING_STACK_BOUNDARY ix86_incoming_stack_boundary
768
769 /* According to Windows x64 software convention, the maximum stack allocatable
770    in the prologue is 4G - 8 bytes.  Furthermore, there is a limited set of
771    instructions allowed to adjust the stack pointer in the epilog, forcing the
772    use of frame pointer for frames larger than 2 GB.  This theorical limit
773    is reduced by 256, an over-estimated upper bound for the stack use by the
774    prologue.
775    We define only one threshold for both the prolog and the epilog.  When the
776    frame size is larger than this threshold, we allocate the area to save SSE
777    regs, then save them, and then allocate the remaining.  There is no SEH
778    unwind info for this later allocation.  */
779 #define SEH_MAX_FRAME_SIZE ((2U << 30) - 256)
780
781 /* Target OS keeps a vector-aligned (128-bit, 16-byte) stack.  This is
782    mandatory for the 64-bit ABI, and may or may not be true for other
783    operating systems.  */
784 #define TARGET_KEEPS_VECTOR_ALIGNED_STACK TARGET_64BIT
785
786 /* Minimum allocation boundary for the code of a function.  */
787 #define FUNCTION_BOUNDARY 8
788
789 /* C++ stores the virtual bit in the lowest bit of function pointers.  */
790 #define TARGET_PTRMEMFUNC_VBIT_LOCATION ptrmemfunc_vbit_in_pfn
791
792 /* Minimum size in bits of the largest boundary to which any
793    and all fundamental data types supported by the hardware
794    might need to be aligned. No data type wants to be aligned
795    rounder than this.
796
797    Pentium+ prefers DFmode values to be aligned to 64 bit boundary
798    and Pentium Pro XFmode values at 128 bit boundaries.  */
799
800 #define BIGGEST_ALIGNMENT \
801   (TARGET_AVX512F ? 512 : (TARGET_AVX ? 256 : 128))
802
803 /* Maximum stack alignment.  */
804 #define MAX_STACK_ALIGNMENT MAX_OFILE_ALIGNMENT
805
806 /* Alignment value for attribute ((aligned)).  It is a constant since
807    it is the part of the ABI.  We shouldn't change it with -mavx.  */
808 #define ATTRIBUTE_ALIGNED_VALUE 128
809
810 /* Decide whether a variable of mode MODE should be 128 bit aligned.  */
811 #define ALIGN_MODE_128(MODE) \
812  ((MODE) == XFmode || SSE_REG_MODE_P (MODE))
813
814 /* The published ABIs say that doubles should be aligned on word
815    boundaries, so lower the alignment for structure fields unless
816    -malign-double is set.  */
817
818 /* ??? Blah -- this macro is used directly by libobjc.  Since it
819    supports no vector modes, cut out the complexity and fall back
820    on BIGGEST_FIELD_ALIGNMENT.  */
821 #ifdef IN_TARGET_LIBS
822 #ifdef __x86_64__
823 #define BIGGEST_FIELD_ALIGNMENT 128
824 #else
825 #define BIGGEST_FIELD_ALIGNMENT 32
826 #endif
827 #else
828 #define ADJUST_FIELD_ALIGN(FIELD, COMPUTED) \
829    x86_field_alignment (FIELD, COMPUTED)
830 #endif
831
832 /* If defined, a C expression to compute the alignment given to a
833    constant that is being placed in memory.  EXP is the constant
834    and ALIGN is the alignment that the object would ordinarily have.
835    The value of this macro is used instead of that alignment to align
836    the object.
837
838    If this macro is not defined, then ALIGN is used.
839
840    The typical use of this macro is to increase alignment for string
841    constants to be word aligned so that `strcpy' calls that copy
842    constants can be done inline.  */
843
844 #define CONSTANT_ALIGNMENT(EXP, ALIGN) ix86_constant_alignment ((EXP), (ALIGN))
845
846 /* If defined, a C expression to compute the alignment for a static
847    variable.  TYPE is the data type, and ALIGN is the alignment that
848    the object would ordinarily have.  The value of this macro is used
849    instead of that alignment to align the object.
850
851    If this macro is not defined, then ALIGN is used.
852
853    One use of this macro is to increase alignment of medium-size
854    data to make it all fit in fewer cache lines.  Another is to
855    cause character arrays to be word-aligned so that `strcpy' calls
856    that copy constants to character arrays can be done inline.  */
857
858 #define DATA_ALIGNMENT(TYPE, ALIGN) \
859   ix86_data_alignment ((TYPE), (ALIGN), true)
860
861 /* Similar to DATA_ALIGNMENT, but for the cases where the ABI mandates
862    some alignment increase, instead of optimization only purposes.  E.g.
863    AMD x86-64 psABI says that variables with array type larger than 15 bytes
864    must be aligned to 16 byte boundaries.
865
866    If this macro is not defined, then ALIGN is used.  */
867
868 #define DATA_ABI_ALIGNMENT(TYPE, ALIGN) \
869   ix86_data_alignment ((TYPE), (ALIGN), false)
870
871 /* If defined, a C expression to compute the alignment for a local
872    variable.  TYPE is the data type, and ALIGN is the alignment that
873    the object would ordinarily have.  The value of this macro is used
874    instead of that alignment to align the object.
875
876    If this macro is not defined, then ALIGN is used.
877
878    One use of this macro is to increase alignment of medium-size
879    data to make it all fit in fewer cache lines.  */
880
881 #define LOCAL_ALIGNMENT(TYPE, ALIGN) \
882   ix86_local_alignment ((TYPE), VOIDmode, (ALIGN))
883
884 /* If defined, a C expression to compute the alignment for stack slot.
885    TYPE is the data type, MODE is the widest mode available, and ALIGN
886    is the alignment that the slot would ordinarily have.  The value of
887    this macro is used instead of that alignment to align the slot.
888
889    If this macro is not defined, then ALIGN is used when TYPE is NULL,
890    Otherwise, LOCAL_ALIGNMENT will be used.
891
892    One use of this macro is to set alignment of stack slot to the
893    maximum alignment of all possible modes which the slot may have.  */
894
895 #define STACK_SLOT_ALIGNMENT(TYPE, MODE, ALIGN) \
896   ix86_local_alignment ((TYPE), (MODE), (ALIGN))
897
898 /* If defined, a C expression to compute the alignment for a local
899    variable DECL.
900
901    If this macro is not defined, then
902    LOCAL_ALIGNMENT (TREE_TYPE (DECL), DECL_ALIGN (DECL)) will be used.
903
904    One use of this macro is to increase alignment of medium-size
905    data to make it all fit in fewer cache lines.  */
906
907 #define LOCAL_DECL_ALIGNMENT(DECL) \
908   ix86_local_alignment ((DECL), VOIDmode, DECL_ALIGN (DECL))
909
910 /* If defined, a C expression to compute the minimum required alignment
911    for dynamic stack realignment purposes for EXP (a TYPE or DECL),
912    MODE, assuming normal alignment ALIGN.
913
914    If this macro is not defined, then (ALIGN) will be used.  */
915
916 #define MINIMUM_ALIGNMENT(EXP, MODE, ALIGN) \
917   ix86_minimum_alignment (EXP, MODE, ALIGN)
918
919
920 /* Set this nonzero if move instructions will actually fail to work
921    when given unaligned data.  */
922 #define STRICT_ALIGNMENT 0
923
924 /* If bit field type is int, don't let it cross an int,
925    and give entire struct the alignment of an int.  */
926 /* Required on the 386 since it doesn't have bit-field insns.  */
927 #define PCC_BITFIELD_TYPE_MATTERS 1
928 \f
929 /* Standard register usage.  */
930
931 /* This processor has special stack-like registers.  See reg-stack.c
932    for details.  */
933
934 #define STACK_REGS
935
936 #define IS_STACK_MODE(MODE)                                     \
937   (((MODE) == SFmode && !(TARGET_SSE && TARGET_SSE_MATH))       \
938    || ((MODE) == DFmode && !(TARGET_SSE2 && TARGET_SSE_MATH))   \
939    || (MODE) == XFmode)
940
941 /* Number of actual hardware registers.
942    The hardware registers are assigned numbers for the compiler
943    from 0 to just below FIRST_PSEUDO_REGISTER.
944    All registers that the compiler knows about must be given numbers,
945    even those that are not normally considered general registers.
946
947    In the 80386 we give the 8 general purpose registers the numbers 0-7.
948    We number the floating point registers 8-15.
949    Note that registers 0-7 can be accessed as a  short or int,
950    while only 0-3 may be used with byte `mov' instructions.
951
952    Reg 16 does not correspond to any hardware register, but instead
953    appears in the RTL as an argument pointer prior to reload, and is
954    eliminated during reloading in favor of either the stack or frame
955    pointer.  */
956
957 #define FIRST_PSEUDO_REGISTER 81
958
959 /* Number of hardware registers that go into the DWARF-2 unwind info.
960    If not defined, equals FIRST_PSEUDO_REGISTER.  */
961
962 #define DWARF_FRAME_REGISTERS 17
963
964 /* 1 for registers that have pervasive standard uses
965    and are not available for the register allocator.
966    On the 80386, the stack pointer is such, as is the arg pointer.
967
968    REX registers are disabled for 32bit targets in
969    TARGET_CONDITIONAL_REGISTER_USAGE.  */
970
971 #define FIXED_REGISTERS                                         \
972 /*ax,dx,cx,bx,si,di,bp,sp,st,st1,st2,st3,st4,st5,st6,st7*/      \
973 {  0, 0, 0, 0, 0, 0, 0, 1, 0,  0,  0,  0,  0,  0,  0,  0,       \
974 /*arg,flags,fpsr,fpcr,frame*/                                   \
975     1,    1,   1,   1,    1,                                    \
976 /*xmm0,xmm1,xmm2,xmm3,xmm4,xmm5,xmm6,xmm7*/                     \
977      0,   0,   0,   0,   0,   0,   0,   0,                      \
978 /* mm0, mm1, mm2, mm3, mm4, mm5, mm6, mm7*/                     \
979      0,   0,   0,   0,   0,   0,   0,   0,                      \
980 /*  r8,  r9, r10, r11, r12, r13, r14, r15*/                     \
981      0,   0,   0,   0,   0,   0,   0,   0,                      \
982 /*xmm8,xmm9,xmm10,xmm11,xmm12,xmm13,xmm14,xmm15*/               \
983      0,   0,    0,    0,    0,    0,    0,    0,                \
984 /*xmm16,xmm17,xmm18,xmm19,xmm20,xmm21,xmm22,xmm23*/             \
985      0,   0,    0,    0,    0,    0,    0,    0,                \
986 /*xmm24,xmm25,xmm26,xmm27,xmm28,xmm29,xmm30,xmm31*/             \
987      0,   0,    0,    0,    0,    0,    0,    0,                \
988 /*  k0,  k1, k2, k3, k4, k5, k6, k7*/                           \
989      0,  0,   0,  0,  0,  0,  0,  0,                            \
990 /*   b0, b1, b2, b3*/                                           \
991      0,  0,  0,  0 }
992
993 /* 1 for registers not available across function calls.
994    These must include the FIXED_REGISTERS and also any
995    registers that can be used without being saved.
996    The latter must include the registers where values are returned
997    and the register where structure-value addresses are passed.
998    Aside from that, you can include as many other registers as you like.
999
1000    Value is set to 1 if the register is call used unconditionally.
1001    Bit one is set if the register is call used on TARGET_32BIT ABI.
1002    Bit two is set if the register is call used on TARGET_64BIT ABI.
1003    Bit three is set if the register is call used on TARGET_64BIT_MS_ABI.
1004
1005    Proper values are computed in TARGET_CONDITIONAL_REGISTER_USAGE.  */
1006
1007 #define CALL_USED_REGISTERS                                     \
1008 /*ax,dx,cx,bx,si,di,bp,sp,st,st1,st2,st3,st4,st5,st6,st7*/      \
1009 {  1, 1, 1, 0, 4, 4, 0, 1, 1,  1,  1,  1,  1,  1,  1,  1,       \
1010 /*arg,flags,fpsr,fpcr,frame*/                                   \
1011     1,   1,    1,   1,    1,                                    \
1012 /*xmm0,xmm1,xmm2,xmm3,xmm4,xmm5,xmm6,xmm7*/                     \
1013      1,   1,   1,   1,   1,   1,   6,   6,                      \
1014 /* mm0, mm1, mm2, mm3, mm4, mm5, mm6, mm7*/                     \
1015      1,   1,   1,   1,   1,   1,   1,   1,                      \
1016 /*  r8,  r9, r10, r11, r12, r13, r14, r15*/                     \
1017      1,   1,   1,   1,   2,   2,   2,   2,                      \
1018 /*xmm8,xmm9,xmm10,xmm11,xmm12,xmm13,xmm14,xmm15*/               \
1019      6,   6,    6,    6,    6,    6,    6,    6,                \
1020 /*xmm16,xmm17,xmm18,xmm19,xmm20,xmm21,xmm22,xmm23*/             \
1021      6,    6,     6,    6,    6,    6,    6,    6,              \
1022 /*xmm24,xmm25,xmm26,xmm27,xmm28,xmm29,xmm30,xmm31*/             \
1023      6,    6,     6,    6,    6,    6,    6,    6,              \
1024  /* k0,  k1,  k2,  k3,  k4,  k5,  k6,  k7*/                     \
1025      1,   1,   1,   1,   1,   1,   1,   1,                      \
1026 /*   b0, b1, b2, b3*/                                           \
1027      1,  1,  1,  1 }
1028
1029 /* Order in which to allocate registers.  Each register must be
1030    listed once, even those in FIXED_REGISTERS.  List frame pointer
1031    late and fixed registers last.  Note that, in general, we prefer
1032    registers listed in CALL_USED_REGISTERS, keeping the others
1033    available for storage of persistent values.
1034
1035    The ADJUST_REG_ALLOC_ORDER actually overwrite the order,
1036    so this is just empty initializer for array.  */
1037
1038 #define REG_ALLOC_ORDER                                         \
1039 {  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,\
1040    18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,  \
1041    33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,  \
1042    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,  \
1043    63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,  \
1044    78, 79, 80 }
1045
1046 /* ADJUST_REG_ALLOC_ORDER is a macro which permits reg_alloc_order
1047    to be rearranged based on a particular function.  When using sse math,
1048    we want to allocate SSE before x87 registers and vice versa.  */
1049
1050 #define ADJUST_REG_ALLOC_ORDER x86_order_regs_for_local_alloc ()
1051
1052
1053 #define OVERRIDE_ABI_FORMAT(FNDECL) ix86_call_abi_override (FNDECL)
1054
1055 /* Return number of consecutive hard regs needed starting at reg REGNO
1056    to hold something of mode MODE.
1057    This is ordinarily the length in words of a value of mode MODE
1058    but can be less for certain modes in special long registers.
1059
1060    Actually there are no two word move instructions for consecutive
1061    registers.  And only registers 0-3 may have mov byte instructions
1062    applied to them.  */
1063
1064 #define HARD_REGNO_NREGS(REGNO, MODE)                                   \
1065   (STACK_REGNO_P (REGNO) || SSE_REGNO_P (REGNO) || MMX_REGNO_P (REGNO)  \
1066    || MASK_REGNO_P (REGNO) || BND_REGNO_P (REGNO)                       \
1067    ? (COMPLEX_MODE_P (MODE) ? 2 : 1)                                    \
1068    : ((MODE) == XFmode                                                  \
1069       ? (TARGET_64BIT ? 2 : 3)                                          \
1070       : (MODE) == XCmode                                                \
1071       ? (TARGET_64BIT ? 4 : 6)                                          \
1072       : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1073
1074 #define HARD_REGNO_NREGS_HAS_PADDING(REGNO, MODE)                       \
1075   ((TARGET_128BIT_LONG_DOUBLE && !TARGET_64BIT)                         \
1076    ? (STACK_REGNO_P (REGNO) || SSE_REGNO_P (REGNO) || MMX_REGNO_P (REGNO) \
1077       ? 0                                                               \
1078       : ((MODE) == XFmode || (MODE) == XCmode))                         \
1079    : 0)
1080
1081 #define HARD_REGNO_NREGS_WITH_PADDING(REGNO, MODE) ((MODE) == XFmode ? 4 : 8)
1082
1083 #define VALID_AVX256_REG_MODE(MODE)                                     \
1084   ((MODE) == V32QImode || (MODE) == V16HImode || (MODE) == V8SImode     \
1085    || (MODE) == V4DImode || (MODE) == V2TImode || (MODE) == V8SFmode    \
1086    || (MODE) == V4DFmode)
1087
1088 #define VALID_AVX256_REG_OR_OI_MODE(MODE)               \
1089   (VALID_AVX256_REG_MODE (MODE) || (MODE) == OImode)
1090
1091 #define VALID_AVX512F_SCALAR_MODE(MODE)                                 \
1092   ((MODE) == DImode || (MODE) == DFmode || (MODE) == SImode             \
1093    || (MODE) == SFmode)
1094
1095 #define VALID_AVX512F_REG_MODE(MODE)                                    \
1096   ((MODE) == V8DImode || (MODE) == V8DFmode || (MODE) == V64QImode      \
1097    || (MODE) == V16SImode || (MODE) == V16SFmode || (MODE) == V32HImode \
1098    || (MODE) == V4TImode)
1099
1100 #define VALID_AVX512VL_128_REG_MODE(MODE)                                       \
1101   ((MODE) == V2DImode || (MODE) == V2DFmode || (MODE) == V16QImode      \
1102    || (MODE) == V4SImode || (MODE) == V4SFmode || (MODE) == V8HImode)
1103
1104 #define VALID_SSE2_REG_MODE(MODE)                                       \
1105   ((MODE) == V16QImode || (MODE) == V8HImode || (MODE) == V2DFmode      \
1106    || (MODE) == V2DImode || (MODE) == DFmode)
1107
1108 #define VALID_SSE_REG_MODE(MODE)                                        \
1109   ((MODE) == V1TImode || (MODE) == TImode                               \
1110    || (MODE) == V4SFmode || (MODE) == V4SImode                          \
1111    || (MODE) == SFmode || (MODE) == TFmode)
1112
1113 #define VALID_MMX_REG_MODE_3DNOW(MODE) \
1114   ((MODE) == V2SFmode || (MODE) == SFmode)
1115
1116 #define VALID_MMX_REG_MODE(MODE)                                        \
1117   ((MODE == V1DImode) || (MODE) == DImode                               \
1118    || (MODE) == V2SImode || (MODE) == SImode                            \
1119    || (MODE) == V4HImode || (MODE) == V8QImode)
1120
1121 #define VALID_BND_REG_MODE(MODE) \
1122   (TARGET_64BIT ? (MODE) == BND64mode : (MODE) == BND32mode)
1123
1124 #define VALID_DFP_MODE_P(MODE) \
1125   ((MODE) == SDmode || (MODE) == DDmode || (MODE) == TDmode)
1126
1127 #define VALID_FP_MODE_P(MODE)                                           \
1128   ((MODE) == SFmode || (MODE) == DFmode || (MODE) == XFmode             \
1129    || (MODE) == SCmode || (MODE) == DCmode || (MODE) == XCmode)         \
1130
1131 #define VALID_INT_MODE_P(MODE)                                          \
1132   ((MODE) == QImode || (MODE) == HImode || (MODE) == SImode             \
1133    || (MODE) == DImode                                                  \
1134    || (MODE) == CQImode || (MODE) == CHImode || (MODE) == CSImode       \
1135    || (MODE) == CDImode                                                 \
1136    || (TARGET_64BIT && ((MODE) == TImode || (MODE) == CTImode           \
1137                         || (MODE) == TFmode || (MODE) == TCmode)))
1138
1139 /* Return true for modes passed in SSE registers.  */
1140 #define SSE_REG_MODE_P(MODE)                                            \
1141   ((MODE) == V1TImode || (MODE) == TImode || (MODE) == V16QImode        \
1142    || (MODE) == TFmode || (MODE) == V8HImode || (MODE) == V2DFmode      \
1143    || (MODE) == V2DImode || (MODE) == V4SFmode || (MODE) == V4SImode    \
1144    || (MODE) == V32QImode || (MODE) == V16HImode || (MODE) == V8SImode  \
1145    || (MODE) == V4DImode || (MODE) == V8SFmode || (MODE) == V4DFmode    \
1146    || (MODE) == V2TImode || (MODE) == V8DImode || (MODE) == V64QImode   \
1147    || (MODE) == V16SImode || (MODE) == V32HImode || (MODE) == V8DFmode  \
1148    || (MODE) == V16SFmode)
1149
1150 #define VALID_MASK_REG_MODE(MODE) ((MODE) == HImode || (MODE) == QImode)
1151
1152 #define VALID_MASK_AVX512BW_MODE(MODE) ((MODE) == SImode || (MODE) == DImode)
1153
1154 /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE.  */
1155
1156 #define HARD_REGNO_MODE_OK(REGNO, MODE) \
1157    ix86_hard_regno_mode_ok ((REGNO), (MODE))
1158
1159 /* Value is 1 if it is a good idea to tie two pseudo registers
1160    when one has mode MODE1 and one has mode MODE2.
1161    If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
1162    for any hard reg, then this must be 0 for correct output.  */
1163
1164 #define MODES_TIEABLE_P(MODE1, MODE2)  ix86_modes_tieable_p (MODE1, MODE2)
1165
1166 /* It is possible to write patterns to move flags; but until someone
1167    does it,  */
1168 #define AVOID_CCMODE_COPIES
1169
1170 /* Specify the modes required to caller save a given hard regno.
1171    We do this on i386 to prevent flags from being saved at all.
1172
1173    Kill any attempts to combine saving of modes.  */
1174
1175 #define HARD_REGNO_CALLER_SAVE_MODE(REGNO, NREGS, MODE)                 \
1176   (CC_REGNO_P (REGNO) ? VOIDmode                                        \
1177    : (MODE) == VOIDmode && (NREGS) != 1 ? VOIDmode                      \
1178    : (MODE) == VOIDmode ? choose_hard_reg_mode ((REGNO), (NREGS), false) \
1179    : (MODE) == HImode && !(TARGET_PARTIAL_REG_STALL                     \
1180                            || MASK_REGNO_P (REGNO)) ? SImode            \
1181    : (MODE) == QImode && !(TARGET_64BIT || QI_REGNO_P (REGNO)           \
1182                            || MASK_REGNO_P (REGNO)) ? SImode            \
1183    : (MODE))
1184
1185 /* The only ABI that saves SSE registers across calls is Win64 (thus no
1186    need to check the current ABI here), and with AVX enabled Win64 only
1187    guarantees that the low 16 bytes are saved.  */
1188 #define HARD_REGNO_CALL_PART_CLOBBERED(REGNO, MODE)             \
1189   (SSE_REGNO_P (REGNO) && GET_MODE_SIZE (MODE) > 16)
1190
1191 /* Specify the registers used for certain standard purposes.
1192    The values of these macros are register numbers.  */
1193
1194 /* on the 386 the pc register is %eip, and is not usable as a general
1195    register.  The ordinary mov instructions won't work */
1196 /* #define PC_REGNUM  */
1197
1198 /* Register to use for pushing function arguments.  */
1199 #define STACK_POINTER_REGNUM 7
1200
1201 /* Base register for access to local variables of the function.  */
1202 #define HARD_FRAME_POINTER_REGNUM 6
1203
1204 /* Base register for access to local variables of the function.  */
1205 #define FRAME_POINTER_REGNUM 20
1206
1207 /* First floating point reg */
1208 #define FIRST_FLOAT_REG 8
1209
1210 /* First & last stack-like regs */
1211 #define FIRST_STACK_REG FIRST_FLOAT_REG
1212 #define LAST_STACK_REG (FIRST_FLOAT_REG + 7)
1213
1214 #define FIRST_SSE_REG (FRAME_POINTER_REGNUM + 1)
1215 #define LAST_SSE_REG  (FIRST_SSE_REG + 7)
1216
1217 #define FIRST_MMX_REG  (LAST_SSE_REG + 1)   /*29*/
1218 #define LAST_MMX_REG   (FIRST_MMX_REG + 7)
1219
1220 #define FIRST_REX_INT_REG  (LAST_MMX_REG + 1) /*37*/
1221 #define LAST_REX_INT_REG   (FIRST_REX_INT_REG + 7)
1222
1223 #define FIRST_REX_SSE_REG  (LAST_REX_INT_REG + 1) /*45*/
1224 #define LAST_REX_SSE_REG   (FIRST_REX_SSE_REG + 7)
1225
1226 #define FIRST_EXT_REX_SSE_REG  (LAST_REX_SSE_REG + 1) /*53*/
1227 #define LAST_EXT_REX_SSE_REG   (FIRST_EXT_REX_SSE_REG + 15) /*68*/
1228
1229 #define FIRST_MASK_REG  (LAST_EXT_REX_SSE_REG + 1) /*69*/
1230 #define LAST_MASK_REG   (FIRST_MASK_REG + 7) /*76*/
1231
1232 #define FIRST_BND_REG  (LAST_MASK_REG + 1) /*77*/
1233 #define LAST_BND_REG   (FIRST_BND_REG + 3) /*80*/
1234
1235 /* Override this in other tm.h files to cope with various OS lossage
1236    requiring a frame pointer.  */
1237 #ifndef SUBTARGET_FRAME_POINTER_REQUIRED
1238 #define SUBTARGET_FRAME_POINTER_REQUIRED 0
1239 #endif
1240
1241 /* Make sure we can access arbitrary call frames.  */
1242 #define SETUP_FRAME_ADDRESSES()  ix86_setup_frame_addresses ()
1243
1244 /* Base register for access to arguments of the function.  */
1245 #define ARG_POINTER_REGNUM 16
1246
1247 /* Register to hold the addressing base for position independent
1248    code access to data items.  We don't use PIC pointer for 64bit
1249    mode.  Define the regnum to dummy value to prevent gcc from
1250    pessimizing code dealing with EBX.
1251
1252    To avoid clobbering a call-saved register unnecessarily, we renumber
1253    the pic register when possible.  The change is visible after the
1254    prologue has been emitted.  */
1255
1256 #define REAL_PIC_OFFSET_TABLE_REGNUM  (TARGET_64BIT ? R15_REG : BX_REG)
1257
1258 #define PIC_OFFSET_TABLE_REGNUM                                         \
1259   (ix86_use_pseudo_pic_reg ()                                           \
1260    ? (pic_offset_table_rtx                                              \
1261       ? INVALID_REGNUM                                                  \
1262       : REAL_PIC_OFFSET_TABLE_REGNUM)                                   \
1263    : INVALID_REGNUM)
1264
1265 #define GOT_SYMBOL_NAME "_GLOBAL_OFFSET_TABLE_"
1266
1267 /* This is overridden by <cygwin.h>.  */
1268 #define MS_AGGREGATE_RETURN 0
1269
1270 #define KEEP_AGGREGATE_RETURN_POINTER 0
1271 \f
1272 /* Define the classes of registers for register constraints in the
1273    machine description.  Also define ranges of constants.
1274
1275    One of the classes must always be named ALL_REGS and include all hard regs.
1276    If there is more than one class, another class must be named NO_REGS
1277    and contain no registers.
1278
1279    The name GENERAL_REGS must be the name of a class (or an alias for
1280    another name such as ALL_REGS).  This is the class of registers
1281    that is allowed by "g" or "r" in a register constraint.
1282    Also, registers outside this class are allocated only when
1283    instructions express preferences for them.
1284
1285    The classes must be numbered in nondecreasing order; that is,
1286    a larger-numbered class must never be contained completely
1287    in a smaller-numbered class.
1288
1289    For any two classes, it is very desirable that there be another
1290    class that represents their union.
1291
1292    It might seem that class BREG is unnecessary, since no useful 386
1293    opcode needs reg %ebx.  But some systems pass args to the OS in ebx,
1294    and the "b" register constraint is useful in asms for syscalls.
1295
1296    The flags, fpsr and fpcr registers are in no class.  */
1297
1298 enum reg_class
1299 {
1300   NO_REGS,
1301   AREG, DREG, CREG, BREG, SIREG, DIREG,
1302   AD_REGS,                      /* %eax/%edx for DImode */
1303   Q_REGS,                       /* %eax %ebx %ecx %edx */
1304   NON_Q_REGS,                   /* %esi %edi %ebp %esp */
1305   INDEX_REGS,                   /* %eax %ebx %ecx %edx %esi %edi %ebp */
1306   LEGACY_REGS,                  /* %eax %ebx %ecx %edx %esi %edi %ebp %esp */
1307   CLOBBERED_REGS,               /* call-clobbered integer registers */
1308   GENERAL_REGS,                 /* %eax %ebx %ecx %edx %esi %edi %ebp %esp
1309                                    %r8 %r9 %r10 %r11 %r12 %r13 %r14 %r15 */
1310   FP_TOP_REG, FP_SECOND_REG,    /* %st(0) %st(1) */
1311   FLOAT_REGS,
1312   SSE_FIRST_REG,
1313   NO_REX_SSE_REGS,
1314   SSE_REGS,
1315   EVEX_SSE_REGS,
1316   BND_REGS,
1317   ALL_SSE_REGS,
1318   MMX_REGS,
1319   FP_TOP_SSE_REGS,
1320   FP_SECOND_SSE_REGS,
1321   FLOAT_SSE_REGS,
1322   FLOAT_INT_REGS,
1323   INT_SSE_REGS,
1324   FLOAT_INT_SSE_REGS,
1325   MASK_EVEX_REGS,
1326   MASK_REGS,
1327   ALL_REGS, LIM_REG_CLASSES
1328 };
1329
1330 #define N_REG_CLASSES ((int) LIM_REG_CLASSES)
1331
1332 #define INTEGER_CLASS_P(CLASS) \
1333   reg_class_subset_p ((CLASS), GENERAL_REGS)
1334 #define FLOAT_CLASS_P(CLASS) \
1335   reg_class_subset_p ((CLASS), FLOAT_REGS)
1336 #define SSE_CLASS_P(CLASS) \
1337   reg_class_subset_p ((CLASS), ALL_SSE_REGS)
1338 #define MMX_CLASS_P(CLASS) \
1339   ((CLASS) == MMX_REGS)
1340 #define MAYBE_INTEGER_CLASS_P(CLASS) \
1341   reg_classes_intersect_p ((CLASS), GENERAL_REGS)
1342 #define MAYBE_FLOAT_CLASS_P(CLASS) \
1343   reg_classes_intersect_p ((CLASS), FLOAT_REGS)
1344 #define MAYBE_SSE_CLASS_P(CLASS) \
1345   reg_classes_intersect_p ((CLASS), ALL_SSE_REGS)
1346 #define MAYBE_MMX_CLASS_P(CLASS) \
1347   reg_classes_intersect_p ((CLASS), MMX_REGS)
1348 #define MAYBE_MASK_CLASS_P(CLASS) \
1349   reg_classes_intersect_p ((CLASS), MASK_REGS)
1350
1351 #define Q_CLASS_P(CLASS) \
1352   reg_class_subset_p ((CLASS), Q_REGS)
1353
1354 #define MAYBE_NON_Q_CLASS_P(CLASS) \
1355   reg_classes_intersect_p ((CLASS), NON_Q_REGS)
1356
1357 /* Give names of register classes as strings for dump file.  */
1358
1359 #define REG_CLASS_NAMES \
1360 {  "NO_REGS",                           \
1361    "AREG", "DREG", "CREG", "BREG",      \
1362    "SIREG", "DIREG",                    \
1363    "AD_REGS",                           \
1364    "Q_REGS", "NON_Q_REGS",              \
1365    "INDEX_REGS",                        \
1366    "LEGACY_REGS",                       \
1367    "CLOBBERED_REGS",                    \
1368    "GENERAL_REGS",                      \
1369    "FP_TOP_REG", "FP_SECOND_REG",       \
1370    "FLOAT_REGS",                        \
1371    "SSE_FIRST_REG",                     \
1372    "NO_REX_SSE_REGS",                   \
1373    "SSE_REGS",                          \
1374    "EVEX_SSE_REGS",                     \
1375    "BND_REGS",                          \
1376    "ALL_SSE_REGS",                      \
1377    "MMX_REGS",                          \
1378    "FP_TOP_SSE_REGS",                   \
1379    "FP_SECOND_SSE_REGS",                \
1380    "FLOAT_SSE_REGS",                    \
1381    "FLOAT_INT_REGS",                    \
1382    "INT_SSE_REGS",                      \
1383    "FLOAT_INT_SSE_REGS",                \
1384    "MASK_EVEX_REGS",                    \
1385    "MASK_REGS",                         \
1386    "ALL_REGS" }
1387
1388 /* Define which registers fit in which classes.  This is an initializer
1389    for a vector of HARD_REG_SET of length N_REG_CLASSES.
1390
1391    Note that CLOBBERED_REGS are calculated by
1392    TARGET_CONDITIONAL_REGISTER_USAGE.  */
1393
1394 #define REG_CLASS_CONTENTS                                              \
1395 {     { 0x00,       0x0,    0x0 },                                       \
1396       { 0x01,       0x0,    0x0 },       /* AREG */                      \
1397       { 0x02,       0x0,    0x0 },       /* DREG */                      \
1398       { 0x04,       0x0,    0x0 },       /* CREG */                      \
1399       { 0x08,       0x0,    0x0 },       /* BREG */                      \
1400       { 0x10,       0x0,    0x0 },       /* SIREG */                     \
1401       { 0x20,       0x0,    0x0 },       /* DIREG */                     \
1402       { 0x03,       0x0,    0x0 },       /* AD_REGS */                   \
1403       { 0x0f,       0x0,    0x0 },       /* Q_REGS */                    \
1404   { 0x1100f0,    0x1fe0,    0x0 },       /* NON_Q_REGS */                \
1405       { 0x7f,    0x1fe0,    0x0 },       /* INDEX_REGS */                \
1406   { 0x1100ff,       0x0,    0x0 },       /* LEGACY_REGS */               \
1407       { 0x07,       0x0,    0x0 },       /* CLOBBERED_REGS */            \
1408   { 0x1100ff,    0x1fe0,    0x0 },       /* GENERAL_REGS */              \
1409      { 0x100,       0x0,    0x0 },       /* FP_TOP_REG */                \
1410     { 0x0200,       0x0,    0x0 },       /* FP_SECOND_REG */             \
1411     { 0xff00,       0x0,    0x0 },       /* FLOAT_REGS */                \
1412   { 0x200000,       0x0,    0x0 },       /* SSE_FIRST_REG */             \
1413 { 0x1fe00000,  0x000000,    0x0 },       /* NO_REX_SSE_REGS */           \
1414 { 0x1fe00000,  0x1fe000,    0x0 },       /* SSE_REGS */                  \
1415        { 0x0,0xffe00000,   0x1f },       /* EVEX_SSE_REGS */             \
1416        { 0x0,       0x0,0x1e000 },       /* BND_REGS */                  \
1417 { 0x1fe00000,0xffffe000,   0x1f },       /* ALL_SSE_REGS */              \
1418 { 0xe0000000,      0x1f,    0x0 },       /* MMX_REGS */                  \
1419 { 0x1fe00100,0xffffe000,   0x1f },       /* FP_TOP_SSE_REG */            \
1420 { 0x1fe00200,0xffffe000,   0x1f },       /* FP_SECOND_SSE_REG */         \
1421 { 0x1fe0ff00,0xffffe000,   0x1f },       /* FLOAT_SSE_REGS */            \
1422 {   0x11ffff,    0x1fe0,    0x0 },       /* FLOAT_INT_REGS */            \
1423 { 0x1ff100ff,0xffffffe0,   0x1f },       /* INT_SSE_REGS */              \
1424 { 0x1ff1ffff,0xffffffe0,   0x1f },       /* FLOAT_INT_SSE_REGS */        \
1425        { 0x0,       0x0, 0x1fc0 },       /* MASK_EVEX_REGS */           \
1426        { 0x0,       0x0, 0x1fe0 },       /* MASK_REGS */                 \
1427 { 0xffffffff,0xffffffff, 0x1fff }                                        \
1428 }
1429
1430 /* The same information, inverted:
1431    Return the class number of the smallest class containing
1432    reg number REGNO.  This could be a conditional expression
1433    or could index an array.  */
1434
1435 #define REGNO_REG_CLASS(REGNO) (regclass_map[REGNO])
1436
1437 /* When this hook returns true for MODE, the compiler allows
1438    registers explicitly used in the rtl to be used as spill registers
1439    but prevents the compiler from extending the lifetime of these
1440    registers.  */
1441 #define TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P hook_bool_mode_true
1442
1443 #define QI_REG_P(X) (REG_P (X) && QI_REGNO_P (REGNO (X)))
1444 #define QI_REGNO_P(N) IN_RANGE ((N), AX_REG, BX_REG)
1445
1446 #define GENERAL_REG_P(X) \
1447   (REG_P (X) && GENERAL_REGNO_P (REGNO (X)))
1448 #define GENERAL_REGNO_P(N) \
1449   (IN_RANGE ((N), AX_REG, SP_REG) || REX_INT_REGNO_P (N))
1450
1451 #define ANY_QI_REG_P(X) (REG_P (X) && ANY_QI_REGNO_P (REGNO (X)))
1452 #define ANY_QI_REGNO_P(N) \
1453   (TARGET_64BIT ? GENERAL_REGNO_P (N) : QI_REGNO_P (N))
1454
1455 #define REX_INT_REG_P(X) (REG_P (X) && REX_INT_REGNO_P (REGNO (X)))
1456 #define REX_INT_REGNO_P(N) \
1457   IN_RANGE ((N), FIRST_REX_INT_REG, LAST_REX_INT_REG)
1458
1459 #define STACK_REG_P(X) (REG_P (X) && STACK_REGNO_P (REGNO (X)))
1460 #define STACK_REGNO_P(N) IN_RANGE ((N), FIRST_STACK_REG, LAST_STACK_REG)
1461
1462 #define ANY_FP_REG_P(X) (REG_P (X) && ANY_FP_REGNO_P (REGNO (X)))
1463 #define ANY_FP_REGNO_P(N) (STACK_REGNO_P (N) || SSE_REGNO_P (N))
1464
1465 #define X87_FLOAT_MODE_P(MODE)  \
1466   (TARGET_80387 && ((MODE) == SFmode || (MODE) == DFmode || (MODE) == XFmode))
1467
1468 #define SSE_REG_P(X) (REG_P (X) && SSE_REGNO_P (REGNO (X)))
1469 #define SSE_REGNO_P(N)                                          \
1470   (IN_RANGE ((N), FIRST_SSE_REG, LAST_SSE_REG)                  \
1471    || REX_SSE_REGNO_P (N)                                       \
1472    || EXT_REX_SSE_REGNO_P (N))
1473
1474 #define REX_SSE_REGNO_P(N) \
1475   IN_RANGE ((N), FIRST_REX_SSE_REG, LAST_REX_SSE_REG)
1476
1477 #define EXT_REX_SSE_REGNO_P(N) \
1478   IN_RANGE ((N), FIRST_EXT_REX_SSE_REG, LAST_EXT_REX_SSE_REG)
1479
1480 #define SSE_REGNO(N) \
1481   ((N) < 8 ? FIRST_SSE_REG + (N) \
1482          : (N) <= LAST_REX_SSE_REG ? (FIRST_REX_SSE_REG + (N) - 8) \
1483                                    : (FIRST_EXT_REX_SSE_REG + (N) - 16))
1484
1485 #define MASK_REG_P(X) (REG_P (X) && MASK_REGNO_P (REGNO (X)))
1486 #define MASK_REGNO_P(N) IN_RANGE ((N), FIRST_MASK_REG, LAST_MASK_REG)
1487 #define ANY_MASK_REG_P(X) (REG_P (X) && MASK_REGNO_P (REGNO (X)))
1488
1489 #define SSE_FLOAT_MODE_P(MODE) \
1490   ((TARGET_SSE && (MODE) == SFmode) || (TARGET_SSE2 && (MODE) == DFmode))
1491
1492 #define FMA4_VEC_FLOAT_MODE_P(MODE) \
1493   (TARGET_FMA4 && ((MODE) == V4SFmode || (MODE) == V2DFmode \
1494                   || (MODE) == V8SFmode || (MODE) == V4DFmode))
1495
1496 #define MMX_REG_P(X) (REG_P (X) && MMX_REGNO_P (REGNO (X)))
1497 #define MMX_REGNO_P(N) IN_RANGE ((N), FIRST_MMX_REG, LAST_MMX_REG)
1498
1499 #define STACK_TOP_P(X) (REG_P (X) && REGNO (X) == FIRST_STACK_REG)
1500
1501 #define CC_REG_P(X) (REG_P (X) && CC_REGNO_P (REGNO (X)))
1502 #define CC_REGNO_P(X) ((X) == FLAGS_REG || (X) == FPSR_REG)
1503
1504 #define BND_REGNO_P(N) IN_RANGE ((N), FIRST_BND_REG, LAST_BND_REG)
1505 #define ANY_BND_REG_P(X) (REG_P (X) && BND_REGNO_P (REGNO (X)))
1506
1507 /* The class value for index registers, and the one for base regs.  */
1508
1509 #define INDEX_REG_CLASS INDEX_REGS
1510 #define BASE_REG_CLASS GENERAL_REGS
1511
1512 /* Place additional restrictions on the register class to use when it
1513    is necessary to be able to hold a value of mode MODE in a reload
1514    register for which class CLASS would ordinarily be used.
1515
1516    We avoid classes containing registers from multiple units due to
1517    the limitation in ix86_secondary_memory_needed.  We limit these
1518    classes to their "natural mode" single unit register class, depending
1519    on the unit availability.
1520
1521    Please note that reg_class_subset_p is not commutative, so these
1522    conditions mean "... if (CLASS) includes ALL registers from the
1523    register set."  */
1524
1525 #define LIMIT_RELOAD_CLASS(MODE, CLASS)                                 \
1526   (((MODE) == QImode && !TARGET_64BIT                                   \
1527     && reg_class_subset_p (Q_REGS, (CLASS))) ? Q_REGS                   \
1528    : (((MODE) == SImode || (MODE) == DImode)                            \
1529       && reg_class_subset_p (GENERAL_REGS, (CLASS))) ? GENERAL_REGS     \
1530    : (SSE_FLOAT_MODE_P (MODE) && TARGET_SSE_MATH                        \
1531       && reg_class_subset_p (SSE_REGS, (CLASS))) ? SSE_REGS             \
1532    : (X87_FLOAT_MODE_P (MODE)                                           \
1533       && reg_class_subset_p (FLOAT_REGS, (CLASS))) ? FLOAT_REGS         \
1534    : (CLASS))
1535
1536 /* If we are copying between general and FP registers, we need a memory
1537    location. The same is true for SSE and MMX registers.  */
1538 #define SECONDARY_MEMORY_NEEDED(CLASS1, CLASS2, MODE) \
1539   ix86_secondary_memory_needed ((CLASS1), (CLASS2), (MODE), 1)
1540
1541 /* Get_secondary_mem widens integral modes to BITS_PER_WORD.
1542    There is no need to emit full 64 bit move on 64 bit targets
1543    for integral modes that can be moved using 32 bit move.  */
1544 #define SECONDARY_MEMORY_NEEDED_MODE(MODE)                      \
1545   (GET_MODE_BITSIZE (MODE) < 32 && INTEGRAL_MODE_P (MODE)       \
1546    ? mode_for_size (32, GET_MODE_CLASS (MODE), 0)               \
1547    : MODE)
1548
1549 /* Return a class of registers that cannot change FROM mode to TO mode.  */
1550
1551 #define CANNOT_CHANGE_MODE_CLASS(FROM, TO, CLASS) \
1552   ix86_cannot_change_mode_class (FROM, TO, CLASS)
1553 \f
1554 /* Stack layout; function entry, exit and calling.  */
1555
1556 /* Define this if pushing a word on the stack
1557    makes the stack pointer a smaller address.  */
1558 #define STACK_GROWS_DOWNWARD
1559
1560 /* Define this to nonzero if the nominal address of the stack frame
1561    is at the high-address end of the local variables;
1562    that is, each additional local variable allocated
1563    goes at a more negative offset in the frame.  */
1564 #define FRAME_GROWS_DOWNWARD 1
1565
1566 /* Offset within stack frame to start allocating local variables at.
1567    If FRAME_GROWS_DOWNWARD, this is the offset to the END of the
1568    first local allocated.  Otherwise, it is the offset to the BEGINNING
1569    of the first local allocated.  */
1570 #define STARTING_FRAME_OFFSET 0
1571
1572 /* If we generate an insn to push BYTES bytes, this says how many the stack
1573    pointer really advances by.  On 386, we have pushw instruction that
1574    decrements by exactly 2 no matter what the position was, there is no pushb.
1575
1576    But as CIE data alignment factor on this arch is -4 for 32bit targets
1577    and -8 for 64bit targets, we need to make sure all stack pointer adjustments
1578    are in multiple of 4 for 32bit targets and 8 for 64bit targets.  */
1579
1580 #define PUSH_ROUNDING(BYTES) \
1581   (((BYTES) + UNITS_PER_WORD - 1) & -UNITS_PER_WORD)
1582
1583 /* If defined, the maximum amount of space required for outgoing arguments
1584    will be computed and placed into the variable `crtl->outgoing_args_size'.
1585    No space will be pushed onto the stack for each call; instead, the
1586    function prologue should increase the stack frame size by this amount.  
1587
1588    In 32bit mode enabling argument accumulation results in about 5% code size
1589    growth becuase move instructions are less compact than push.  In 64bit
1590    mode the difference is less drastic but visible.  
1591
1592    FIXME: Unlike earlier implementations, the size of unwind info seems to
1593    actually grow with accumulation.  Is that because accumulated args
1594    unwind info became unnecesarily bloated?
1595
1596    With the 64-bit MS ABI, we can generate correct code with or without
1597    accumulated args, but because of OUTGOING_REG_PARM_STACK_SPACE the code
1598    generated without accumulated args is terrible.
1599
1600    If stack probes are required, the space used for large function
1601    arguments on the stack must also be probed, so enable
1602    -maccumulate-outgoing-args so this happens in the prologue.  */
1603
1604 #define ACCUMULATE_OUTGOING_ARGS \
1605   ((TARGET_ACCUMULATE_OUTGOING_ARGS && optimize_function_for_speed_p (cfun)) \
1606    || TARGET_STACK_PROBE || TARGET_64BIT_MS_ABI)
1607
1608 /* If defined, a C expression whose value is nonzero when we want to use PUSH
1609    instructions to pass outgoing arguments.  */
1610
1611 #define PUSH_ARGS (TARGET_PUSH_ARGS && !ACCUMULATE_OUTGOING_ARGS)
1612
1613 /* We want the stack and args grow in opposite directions, even if
1614    PUSH_ARGS is 0.  */
1615 #define PUSH_ARGS_REVERSED 1
1616
1617 /* Offset of first parameter from the argument pointer register value.  */
1618 #define FIRST_PARM_OFFSET(FNDECL) 0
1619
1620 /* Define this macro if functions should assume that stack space has been
1621    allocated for arguments even when their values are passed in registers.
1622
1623    The value of this macro is the size, in bytes, of the area reserved for
1624    arguments passed in registers for the function represented by FNDECL.
1625
1626    This space can be allocated by the caller, or be a part of the
1627    machine-dependent stack frame: `OUTGOING_REG_PARM_STACK_SPACE' says
1628    which.  */
1629 #define REG_PARM_STACK_SPACE(FNDECL) ix86_reg_parm_stack_space (FNDECL)
1630
1631 #define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) \
1632   (TARGET_64BIT && ix86_function_type_abi (FNTYPE) == MS_ABI)
1633
1634 /* Define how to find the value returned by a library function
1635    assuming the value has mode MODE.  */
1636
1637 #define LIBCALL_VALUE(MODE) ix86_libcall_value (MODE)
1638
1639 /* Define the size of the result block used for communication between
1640    untyped_call and untyped_return.  The block contains a DImode value
1641    followed by the block used by fnsave and frstor.  */
1642
1643 #define APPLY_RESULT_SIZE (8+108)
1644
1645 /* 1 if N is a possible register number for function argument passing.  */
1646 #define FUNCTION_ARG_REGNO_P(N) ix86_function_arg_regno_p (N)
1647
1648 /* Define a data type for recording info about an argument list
1649    during the scan of that argument list.  This data type should
1650    hold all necessary information about the function itself
1651    and about the args processed so far, enough to enable macros
1652    such as FUNCTION_ARG to determine where the next arg should go.  */
1653
1654 typedef struct ix86_args {
1655   int words;                    /* # words passed so far */
1656   int nregs;                    /* # registers available for passing */
1657   int regno;                    /* next available register number */
1658   int fastcall;                 /* fastcall or thiscall calling convention
1659                                    is used */
1660   int sse_words;                /* # sse words passed so far */
1661   int sse_nregs;                /* # sse registers available for passing */
1662   int warn_avx512f;             /* True when we want to warn
1663                                    about AVX512F ABI.  */
1664   int warn_avx;                 /* True when we want to warn about AVX ABI.  */
1665   int warn_sse;                 /* True when we want to warn about SSE ABI.  */
1666   int warn_mmx;                 /* True when we want to warn about MMX ABI.  */
1667   int sse_regno;                /* next available sse register number */
1668   int mmx_words;                /* # mmx words passed so far */
1669   int mmx_nregs;                /* # mmx registers available for passing */
1670   int mmx_regno;                /* next available mmx register number */
1671   int maybe_vaarg;              /* true for calls to possibly vardic fncts.  */
1672   int caller;                   /* true if it is caller.  */
1673   int float_in_sse;             /* Set to 1 or 2 for 32bit targets if
1674                                    SFmode/DFmode arguments should be passed
1675                                    in SSE registers.  Otherwise 0.  */
1676   int bnd_regno;                /* next available bnd register number */
1677   int bnds_in_bt;               /* number of bounds expected in BT.  */
1678   int force_bnd_pass;           /* number of bounds expected for stdarg arg.  */
1679   int stdarg;                   /* Set to 1 if function is stdarg.  */
1680   enum calling_abi call_abi;    /* Set to SYSV_ABI for sysv abi. Otherwise
1681                                    MS_ABI for ms abi.  */
1682 } CUMULATIVE_ARGS;
1683
1684 /* Initialize a variable CUM of type CUMULATIVE_ARGS
1685    for a call to a function whose data type is FNTYPE.
1686    For a library call, FNTYPE is 0.  */
1687
1688 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \
1689   init_cumulative_args (&(CUM), (FNTYPE), (LIBNAME), (FNDECL), \
1690                         (N_NAMED_ARGS) != -1)
1691
1692 /* Output assembler code to FILE to increment profiler label # LABELNO
1693    for profiling a function entry.  */
1694
1695 #define FUNCTION_PROFILER(FILE, LABELNO) x86_function_profiler (FILE, LABELNO)
1696
1697 #define MCOUNT_NAME "_mcount"
1698
1699 #define MCOUNT_NAME_BEFORE_PROLOGUE "__fentry__"
1700
1701 #define PROFILE_COUNT_REGISTER "edx"
1702
1703 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
1704    the stack pointer does not matter.  The value is tested only in
1705    functions that have frame pointers.
1706    No definition is equivalent to always zero.  */
1707 /* Note on the 386 it might be more efficient not to define this since
1708    we have to restore it ourselves from the frame pointer, in order to
1709    use pop */
1710
1711 #define EXIT_IGNORE_STACK 1
1712
1713 /* Output assembler code for a block containing the constant parts
1714    of a trampoline, leaving space for the variable parts.  */
1715
1716 /* On the 386, the trampoline contains two instructions:
1717      mov #STATIC,ecx
1718      jmp FUNCTION
1719    The trampoline is generated entirely at runtime.  The operand of JMP
1720    is the address of FUNCTION relative to the instruction following the
1721    JMP (which is 5 bytes long).  */
1722
1723 /* Length in units of the trampoline for entering a nested function.  */
1724
1725 #define TRAMPOLINE_SIZE (TARGET_64BIT ? 24 : 10)
1726 \f
1727 /* Definitions for register eliminations.
1728
1729    This is an array of structures.  Each structure initializes one pair
1730    of eliminable registers.  The "from" register number is given first,
1731    followed by "to".  Eliminations of the same "from" register are listed
1732    in order of preference.
1733
1734    There are two registers that can always be eliminated on the i386.
1735    The frame pointer and the arg pointer can be replaced by either the
1736    hard frame pointer or to the stack pointer, depending upon the
1737    circumstances.  The hard frame pointer is not used before reload and
1738    so it is not eligible for elimination.  */
1739
1740 #define ELIMINABLE_REGS                                 \
1741 {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM},           \
1742  { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM},      \
1743  { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM},         \
1744  { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}}    \
1745
1746 /* Define the offset between two registers, one to be eliminated, and the other
1747    its replacement, at the start of a routine.  */
1748
1749 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
1750   ((OFFSET) = ix86_initial_elimination_offset ((FROM), (TO)))
1751 \f
1752 /* Addressing modes, and classification of registers for them.  */
1753
1754 /* Macros to check register numbers against specific register classes.  */
1755
1756 /* These assume that REGNO is a hard or pseudo reg number.
1757    They give nonzero only if REGNO is a hard reg of the suitable class
1758    or a pseudo reg currently allocated to a suitable hard reg.
1759    Since they use reg_renumber, they are safe only once reg_renumber
1760    has been allocated, which happens in reginfo.c during register
1761    allocation.  */
1762
1763 #define REGNO_OK_FOR_INDEX_P(REGNO)                                     \
1764   ((REGNO) < STACK_POINTER_REGNUM                                       \
1765    || REX_INT_REGNO_P (REGNO)                                           \
1766    || (unsigned) reg_renumber[(REGNO)] < STACK_POINTER_REGNUM           \
1767    || REX_INT_REGNO_P ((unsigned) reg_renumber[(REGNO)]))
1768
1769 #define REGNO_OK_FOR_BASE_P(REGNO)                                      \
1770   (GENERAL_REGNO_P (REGNO)                                              \
1771    || (REGNO) == ARG_POINTER_REGNUM                                     \
1772    || (REGNO) == FRAME_POINTER_REGNUM                                   \
1773    || GENERAL_REGNO_P ((unsigned) reg_renumber[(REGNO)]))
1774
1775 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
1776    and check its validity for a certain class.
1777    We have two alternate definitions for each of them.
1778    The usual definition accepts all pseudo regs; the other rejects
1779    them unless they have been allocated suitable hard regs.
1780    The symbol REG_OK_STRICT causes the latter definition to be used.
1781
1782    Most source files want to accept pseudo regs in the hope that
1783    they will get allocated to the class that the insn wants them to be in.
1784    Source files for reload pass need to be strict.
1785    After reload, it makes no difference, since pseudo regs have
1786    been eliminated by then.  */
1787
1788
1789 /* Non strict versions, pseudos are ok.  */
1790 #define REG_OK_FOR_INDEX_NONSTRICT_P(X)                                 \
1791   (REGNO (X) < STACK_POINTER_REGNUM                                     \
1792    || REX_INT_REGNO_P (REGNO (X))                                       \
1793    || REGNO (X) >= FIRST_PSEUDO_REGISTER)
1794
1795 #define REG_OK_FOR_BASE_NONSTRICT_P(X)                                  \
1796   (GENERAL_REGNO_P (REGNO (X))                                          \
1797    || REGNO (X) == ARG_POINTER_REGNUM                                   \
1798    || REGNO (X) == FRAME_POINTER_REGNUM                                 \
1799    || REGNO (X) >= FIRST_PSEUDO_REGISTER)
1800
1801 /* Strict versions, hard registers only */
1802 #define REG_OK_FOR_INDEX_STRICT_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X))
1803 #define REG_OK_FOR_BASE_STRICT_P(X)  REGNO_OK_FOR_BASE_P (REGNO (X))
1804
1805 #ifndef REG_OK_STRICT
1806 #define REG_OK_FOR_INDEX_P(X)  REG_OK_FOR_INDEX_NONSTRICT_P (X)
1807 #define REG_OK_FOR_BASE_P(X)   REG_OK_FOR_BASE_NONSTRICT_P (X)
1808
1809 #else
1810 #define REG_OK_FOR_INDEX_P(X)  REG_OK_FOR_INDEX_STRICT_P (X)
1811 #define REG_OK_FOR_BASE_P(X)   REG_OK_FOR_BASE_STRICT_P (X)
1812 #endif
1813
1814 /* TARGET_LEGITIMATE_ADDRESS_P recognizes an RTL expression
1815    that is a valid memory address for an instruction.
1816    The MODE argument is the machine mode for the MEM expression
1817    that wants to use this address.
1818
1819    The other macros defined here are used only in TARGET_LEGITIMATE_ADDRESS_P,
1820    except for CONSTANT_ADDRESS_P which is usually machine-independent.
1821
1822    See legitimize_pic_address in i386.c for details as to what
1823    constitutes a legitimate address when -fpic is used.  */
1824
1825 #define MAX_REGS_PER_ADDRESS 2
1826
1827 #define CONSTANT_ADDRESS_P(X)  constant_address_p (X)
1828
1829 /* Try a machine-dependent way of reloading an illegitimate address
1830    operand.  If we find one, push the reload and jump to WIN.  This
1831    macro is used in only one place: `find_reloads_address' in reload.c.  */
1832
1833 #define LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, INDL, WIN)      \
1834 do {                                                                    \
1835   if (ix86_legitimize_reload_address ((X), (MODE), (OPNUM),             \
1836                                       (int)(TYPE), (INDL)))             \
1837     goto WIN;                                                           \
1838 } while (0)
1839
1840 /* If defined, a C expression to determine the base term of address X.
1841    This macro is used in only one place: `find_base_term' in alias.c.
1842
1843    It is always safe for this macro to not be defined.  It exists so
1844    that alias analysis can understand machine-dependent addresses.
1845
1846    The typical use of this macro is to handle addresses containing
1847    a label_ref or symbol_ref within an UNSPEC.  */
1848
1849 #define FIND_BASE_TERM(X) ix86_find_base_term (X)
1850
1851 /* Nonzero if the constant value X is a legitimate general operand
1852    when generating PIC code.  It is given that flag_pic is on and
1853    that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */
1854
1855 #define LEGITIMATE_PIC_OPERAND_P(X) legitimate_pic_operand_p (X)
1856
1857 #define SYMBOLIC_CONST(X)       \
1858   (GET_CODE (X) == SYMBOL_REF                                           \
1859    || GET_CODE (X) == LABEL_REF                                         \
1860    || (GET_CODE (X) == CONST && symbolic_reference_mentioned_p (X)))
1861 \f
1862 /* Max number of args passed in registers.  If this is more than 3, we will
1863    have problems with ebx (register #4), since it is a caller save register and
1864    is also used as the pic register in ELF.  So for now, don't allow more than
1865    3 registers to be passed in registers.  */
1866
1867 /* Abi specific values for REGPARM_MAX and SSE_REGPARM_MAX */
1868 #define X86_64_REGPARM_MAX 6
1869 #define X86_64_MS_REGPARM_MAX 4
1870
1871 #define X86_32_REGPARM_MAX 3
1872
1873 #define REGPARM_MAX                                                     \
1874   (TARGET_64BIT                                                         \
1875    ? (TARGET_64BIT_MS_ABI                                               \
1876       ? X86_64_MS_REGPARM_MAX                                           \
1877       : X86_64_REGPARM_MAX)                                             \
1878    : X86_32_REGPARM_MAX)
1879
1880 #define X86_64_SSE_REGPARM_MAX 8
1881 #define X86_64_MS_SSE_REGPARM_MAX 4
1882
1883 #define X86_32_SSE_REGPARM_MAX (TARGET_SSE ? (TARGET_MACHO ? 4 : 3) : 0)
1884
1885 #define SSE_REGPARM_MAX                                                 \
1886   (TARGET_64BIT                                                         \
1887    ? (TARGET_64BIT_MS_ABI                                               \
1888       ? X86_64_MS_SSE_REGPARM_MAX                                       \
1889       : X86_64_SSE_REGPARM_MAX)                                         \
1890    : X86_32_SSE_REGPARM_MAX)
1891
1892 #define MMX_REGPARM_MAX (TARGET_64BIT ? 0 : (TARGET_MMX ? 3 : 0))
1893 \f
1894 /* Specify the machine mode that this machine uses
1895    for the index in the tablejump instruction.  */
1896 #define CASE_VECTOR_MODE \
1897  (!TARGET_LP64 || (flag_pic && ix86_cmodel != CM_LARGE_PIC) ? SImode : DImode)
1898
1899 /* Define this as 1 if `char' should by default be signed; else as 0.  */
1900 #define DEFAULT_SIGNED_CHAR 1
1901
1902 /* Max number of bytes we can move from memory to memory
1903    in one reasonably fast instruction.  */
1904 #define MOVE_MAX 16
1905
1906 /* MOVE_MAX_PIECES is the number of bytes at a time which we can
1907    move efficiently, as opposed to  MOVE_MAX which is the maximum
1908    number of bytes we can move with a single instruction.  */
1909 #define MOVE_MAX_PIECES UNITS_PER_WORD
1910
1911 /* If a memory-to-memory move would take MOVE_RATIO or more simple
1912    move-instruction pairs, we will do a movmem or libcall instead.
1913    Increasing the value will always make code faster, but eventually
1914    incurs high cost in increased code size.
1915
1916    If you don't define this, a reasonable default is used.  */
1917
1918 #define MOVE_RATIO(speed) ((speed) ? ix86_cost->move_ratio : 3)
1919
1920 /* If a clear memory operation would take CLEAR_RATIO or more simple
1921    move-instruction sequences, we will do a clrmem or libcall instead.  */
1922
1923 #define CLEAR_RATIO(speed) ((speed) ? MIN (6, ix86_cost->move_ratio) : 2)
1924
1925 /* Define if shifts truncate the shift count which implies one can
1926    omit a sign-extension or zero-extension of a shift count.
1927
1928    On i386, shifts do truncate the count.  But bit test instructions
1929    take the modulo of the bit offset operand.  */
1930
1931 /* #define SHIFT_COUNT_TRUNCATED */
1932
1933 /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
1934    is done just by pretending it is already truncated.  */
1935 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
1936
1937 /* A macro to update M and UNSIGNEDP when an object whose type is
1938    TYPE and which has the specified mode and signedness is to be
1939    stored in a register.  This macro is only called when TYPE is a
1940    scalar type.
1941
1942    On i386 it is sometimes useful to promote HImode and QImode
1943    quantities to SImode.  The choice depends on target type.  */
1944
1945 #define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE)             \
1946 do {                                                    \
1947   if (((MODE) == HImode && TARGET_PROMOTE_HI_REGS)      \
1948       || ((MODE) == QImode && TARGET_PROMOTE_QI_REGS))  \
1949     (MODE) = SImode;                                    \
1950 } while (0)
1951
1952 /* Specify the machine mode that pointers have.
1953    After generation of rtl, the compiler makes no further distinction
1954    between pointers and any other objects of this machine mode.  */
1955 #define Pmode (ix86_pmode == PMODE_DI ? DImode : SImode)
1956
1957 /* Specify the machine mode that bounds have.  */
1958 #define BNDmode (ix86_pmode == PMODE_DI ? BND64mode : BND32mode)
1959
1960 /* A C expression whose value is zero if pointers that need to be extended
1961    from being `POINTER_SIZE' bits wide to `Pmode' are sign-extended and
1962    greater then zero if they are zero-extended and less then zero if the
1963    ptr_extend instruction should be used.  */
1964
1965 #define POINTERS_EXTEND_UNSIGNED 1
1966
1967 /* A function address in a call instruction
1968    is a byte address (for indexing purposes)
1969    so give the MEM rtx a byte's mode.  */
1970 #define FUNCTION_MODE QImode
1971 \f
1972
1973 /* A C expression for the cost of a branch instruction.  A value of 1
1974    is the default; other values are interpreted relative to that.  */
1975
1976 #define BRANCH_COST(speed_p, predictable_p) \
1977   (!(speed_p) ? 2 : (predictable_p) ? 0 : ix86_branch_cost)
1978
1979 /* An integer expression for the size in bits of the largest integer machine
1980    mode that should actually be used.  We allow pairs of registers.  */
1981 #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (TARGET_64BIT ? TImode : DImode)
1982
1983 /* Define this macro as a C expression which is nonzero if accessing
1984    less than a word of memory (i.e. a `char' or a `short') is no
1985    faster than accessing a word of memory, i.e., if such access
1986    require more than one instruction or if there is no difference in
1987    cost between byte and (aligned) word loads.
1988
1989    When this macro is not defined, the compiler will access a field by
1990    finding the smallest containing object; when it is defined, a
1991    fullword load will be used if alignment permits.  Unless bytes
1992    accesses are faster than word accesses, using word accesses is
1993    preferable since it may eliminate subsequent memory access if
1994    subsequent accesses occur to other fields in the same word of the
1995    structure, but to different bytes.  */
1996
1997 #define SLOW_BYTE_ACCESS 0
1998
1999 /* Nonzero if access to memory by shorts is slow and undesirable.  */
2000 #define SLOW_SHORT_ACCESS 0
2001
2002 /* Define this macro to be the value 1 if unaligned accesses have a
2003    cost many times greater than aligned accesses, for example if they
2004    are emulated in a trap handler.
2005
2006    When this macro is nonzero, the compiler will act as if
2007    `STRICT_ALIGNMENT' were nonzero when generating code for block
2008    moves.  This can cause significantly more instructions to be
2009    produced.  Therefore, do not set this macro nonzero if unaligned
2010    accesses only add a cycle or two to the time for a memory access.
2011
2012    If the value of this macro is always zero, it need not be defined.  */
2013
2014 /* #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 0 */
2015
2016 /* Define this macro if it is as good or better to call a constant
2017    function address than to call an address kept in a register.
2018
2019    Desirable on the 386 because a CALL with a constant address is
2020    faster than one with a register address.  */
2021
2022 #define NO_FUNCTION_CSE
2023 \f
2024 /* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE,
2025    return the mode to be used for the comparison.
2026
2027    For floating-point equality comparisons, CCFPEQmode should be used.
2028    VOIDmode should be used in all other cases.
2029
2030    For integer comparisons against zero, reduce to CCNOmode or CCZmode if
2031    possible, to allow for more combinations.  */
2032
2033 #define SELECT_CC_MODE(OP, X, Y) ix86_cc_mode ((OP), (X), (Y))
2034
2035 /* Return nonzero if MODE implies a floating point inequality can be
2036    reversed.  */
2037
2038 #define REVERSIBLE_CC_MODE(MODE) 1
2039
2040 /* A C expression whose value is reversed condition code of the CODE for
2041    comparison done in CC_MODE mode.  */
2042 #define REVERSE_CONDITION(CODE, MODE) ix86_reverse_condition ((CODE), (MODE))
2043
2044 \f
2045 /* Control the assembler format that we output, to the extent
2046    this does not vary between assemblers.  */
2047
2048 /* How to refer to registers in assembler output.
2049    This sequence is indexed by compiler's hard-register-number (see above).  */
2050
2051 /* In order to refer to the first 8 regs as 32-bit regs, prefix an "e".
2052    For non floating point regs, the following are the HImode names.
2053
2054    For float regs, the stack top is sometimes referred to as "%st(0)"
2055    instead of just "%st".  TARGET_PRINT_OPERAND handles this with the
2056    "y" code.  */
2057
2058 #define HI_REGISTER_NAMES                                               \
2059 {"ax","dx","cx","bx","si","di","bp","sp",                               \
2060  "st","st(1)","st(2)","st(3)","st(4)","st(5)","st(6)","st(7)",          \
2061  "argp", "flags", "fpsr", "fpcr", "frame",                              \
2062  "xmm0","xmm1","xmm2","xmm3","xmm4","xmm5","xmm6","xmm7",               \
2063  "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",                \
2064  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",                  \
2065  "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",  \
2066  "xmm16", "xmm17", "xmm18", "xmm19",                                    \
2067  "xmm20", "xmm21", "xmm22", "xmm23",                                    \
2068  "xmm24", "xmm25", "xmm26", "xmm27",                                    \
2069  "xmm28", "xmm29", "xmm30", "xmm31",                                    \
2070  "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7",                        \
2071  "bnd0", "bnd1", "bnd2", "bnd3" }
2072
2073 #define REGISTER_NAMES HI_REGISTER_NAMES
2074
2075 /* Table of additional register names to use in user input.  */
2076
2077 #define ADDITIONAL_REGISTER_NAMES \
2078 { { "eax", 0 }, { "edx", 1 }, { "ecx", 2 }, { "ebx", 3 },               \
2079   { "esi", 4 }, { "edi", 5 }, { "ebp", 6 }, { "esp", 7 },               \
2080   { "rax", 0 }, { "rdx", 1 }, { "rcx", 2 }, { "rbx", 3 },               \
2081   { "rsi", 4 }, { "rdi", 5 }, { "rbp", 6 }, { "rsp", 7 },               \
2082   { "al", 0 }, { "dl", 1 }, { "cl", 2 }, { "bl", 3 },                   \
2083   { "ah", 0 }, { "dh", 1 }, { "ch", 2 }, { "bh", 3 },                   \
2084   { "ymm0", 21}, { "ymm1", 22}, { "ymm2", 23}, { "ymm3", 24},           \
2085   { "ymm4", 25}, { "ymm5", 26}, { "ymm6", 27}, { "ymm7", 28},           \
2086   { "ymm8", 45}, { "ymm9", 46}, { "ymm10", 47}, { "ymm11", 48},         \
2087   { "ymm12", 49}, { "ymm13", 50}, { "ymm14", 51}, { "ymm15", 52},       \
2088   { "ymm16", 53}, { "ymm17", 54}, { "ymm18", 55}, { "ymm19", 56},       \
2089   { "ymm20", 57}, { "ymm21", 58}, { "ymm22", 59}, { "ymm23", 60},       \
2090   { "ymm24", 61}, { "ymm25", 62}, { "ymm26", 63}, { "ymm27", 64},       \
2091   { "ymm28", 65}, { "ymm29", 66}, { "ymm30", 67}, { "ymm31", 68},       \
2092   { "zmm0", 21}, { "zmm1", 22}, { "zmm2", 23}, { "zmm3", 24},           \
2093   { "zmm4", 25}, { "zmm5", 26}, { "zmm6", 27}, { "zmm7", 28},           \
2094   { "zmm8", 45}, { "zmm9", 46}, { "zmm10", 47}, { "zmm11", 48},         \
2095   { "zmm12", 49}, { "zmm13", 50}, { "zmm14", 51}, { "zmm15", 52},       \
2096   { "zmm16", 53}, { "zmm17", 54}, { "zmm18", 55}, { "zmm19", 56},       \
2097   { "zmm20", 57}, { "zmm21", 58}, { "zmm22", 59}, { "zmm23", 60},       \
2098   { "zmm24", 61}, { "zmm25", 62}, { "zmm26", 63}, { "zmm27", 64},       \
2099   { "zmm28", 65}, { "zmm29", 66}, { "zmm30", 67}, { "zmm31", 68} }
2100
2101 /* Note we are omitting these since currently I don't know how
2102 to get gcc to use these, since they want the same but different
2103 number as al, and ax.
2104 */
2105
2106 #define QI_REGISTER_NAMES \
2107 {"al", "dl", "cl", "bl", "sil", "dil", "bpl", "spl",}
2108
2109 /* These parallel the array above, and can be used to access bits 8:15
2110    of regs 0 through 3.  */
2111
2112 #define QI_HIGH_REGISTER_NAMES \
2113 {"ah", "dh", "ch", "bh", }
2114
2115 /* How to renumber registers for dbx and gdb.  */
2116
2117 #define DBX_REGISTER_NUMBER(N) \
2118   (TARGET_64BIT ? dbx64_register_map[(N)] : dbx_register_map[(N)])
2119
2120 extern int const dbx_register_map[FIRST_PSEUDO_REGISTER];
2121 extern int const dbx64_register_map[FIRST_PSEUDO_REGISTER];
2122 extern int const svr4_dbx_register_map[FIRST_PSEUDO_REGISTER];
2123
2124 extern int const x86_64_ms_sysv_extra_clobbered_registers[12];
2125
2126 /* Before the prologue, RA is at 0(%esp).  */
2127 #define INCOMING_RETURN_ADDR_RTX \
2128   gen_rtx_MEM (VOIDmode, gen_rtx_REG (VOIDmode, STACK_POINTER_REGNUM))
2129
2130 /* After the prologue, RA is at -4(AP) in the current frame.  */
2131 #define RETURN_ADDR_RTX(COUNT, FRAME)                                      \
2132   ((COUNT) == 0                                                            \
2133    ? gen_rtx_MEM (Pmode, plus_constant (Pmode, arg_pointer_rtx,    \
2134                                         -UNITS_PER_WORD))                  \
2135    : gen_rtx_MEM (Pmode, plus_constant (Pmode, FRAME, UNITS_PER_WORD)))
2136
2137 /* PC is dbx register 8; let's use that column for RA.  */
2138 #define DWARF_FRAME_RETURN_COLUMN       (TARGET_64BIT ? 16 : 8)
2139
2140 /* Before the prologue, the top of the frame is at 4(%esp).  */
2141 #define INCOMING_FRAME_SP_OFFSET UNITS_PER_WORD
2142
2143 /* Describe how we implement __builtin_eh_return.  */
2144 #define EH_RETURN_DATA_REGNO(N) ((N) <= DX_REG ? (N) : INVALID_REGNUM)
2145 #define EH_RETURN_STACKADJ_RTX  gen_rtx_REG (Pmode, CX_REG)
2146
2147
2148 /* Select a format to encode pointers in exception handling data.  CODE
2149    is 0 for data, 1 for code labels, 2 for function pointers.  GLOBAL is
2150    true if the symbol may be affected by dynamic relocations.
2151
2152    ??? All x86 object file formats are capable of representing this.
2153    After all, the relocation needed is the same as for the call insn.
2154    Whether or not a particular assembler allows us to enter such, I
2155    guess we'll have to see.  */
2156 #define ASM_PREFERRED_EH_DATA_FORMAT(CODE, GLOBAL)                      \
2157   asm_preferred_eh_data_format ((CODE), (GLOBAL))
2158
2159 /* This is how to output an insn to push a register on the stack.
2160    It need not be very fast code.  */
2161
2162 #define ASM_OUTPUT_REG_PUSH(FILE, REGNO)  \
2163 do {                                                                    \
2164   if (TARGET_64BIT)                                                     \
2165     asm_fprintf ((FILE), "\tpush{q}\t%%r%s\n",                          \
2166                  reg_names[(REGNO)] + (REX_INT_REGNO_P (REGNO) != 0));  \
2167   else                                                                  \
2168     asm_fprintf ((FILE), "\tpush{l}\t%%e%s\n", reg_names[(REGNO)]);     \
2169 } while (0)
2170
2171 /* This is how to output an insn to pop a register from the stack.
2172    It need not be very fast code.  */
2173
2174 #define ASM_OUTPUT_REG_POP(FILE, REGNO)  \
2175 do {                                                                    \
2176   if (TARGET_64BIT)                                                     \
2177     asm_fprintf ((FILE), "\tpop{q}\t%%r%s\n",                           \
2178                  reg_names[(REGNO)] + (REX_INT_REGNO_P (REGNO) != 0));  \
2179   else                                                                  \
2180     asm_fprintf ((FILE), "\tpop{l}\t%%e%s\n", reg_names[(REGNO)]);      \
2181 } while (0)
2182
2183 /* This is how to output an element of a case-vector that is absolute.  */
2184
2185 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)  \
2186   ix86_output_addr_vec_elt ((FILE), (VALUE))
2187
2188 /* This is how to output an element of a case-vector that is relative.  */
2189
2190 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \
2191   ix86_output_addr_diff_elt ((FILE), (VALUE), (REL))
2192
2193 /* When we see %v, we will print the 'v' prefix if TARGET_AVX is true.  */
2194
2195 #define ASM_OUTPUT_AVX_PREFIX(STREAM, PTR)      \
2196 {                                               \
2197   if ((PTR)[0] == '%' && (PTR)[1] == 'v')       \
2198     (PTR) += TARGET_AVX ? 1 : 2;                \
2199 }
2200
2201 /* A C statement or statements which output an assembler instruction
2202    opcode to the stdio stream STREAM.  The macro-operand PTR is a
2203    variable of type `char *' which points to the opcode name in
2204    its "internal" form--the form that is written in the machine
2205    description.  */
2206
2207 #define ASM_OUTPUT_OPCODE(STREAM, PTR) \
2208   ASM_OUTPUT_AVX_PREFIX ((STREAM), (PTR))
2209
2210 /* A C statement to output to the stdio stream FILE an assembler
2211    command to pad the location counter to a multiple of 1<<LOG
2212    bytes if it is within MAX_SKIP bytes.  */
2213
2214 #ifdef HAVE_GAS_MAX_SKIP_P2ALIGN
2215 #undef  ASM_OUTPUT_MAX_SKIP_PAD
2216 #define ASM_OUTPUT_MAX_SKIP_PAD(FILE, LOG, MAX_SKIP)                    \
2217   if ((LOG) != 0)                                                       \
2218     {                                                                   \
2219       if ((MAX_SKIP) == 0)                                              \
2220         fprintf ((FILE), "\t.p2align %d\n", (LOG));                     \
2221       else                                                              \
2222         fprintf ((FILE), "\t.p2align %d,,%d\n", (LOG), (MAX_SKIP));     \
2223     }
2224 #endif
2225
2226 /* Write the extra assembler code needed to declare a function
2227    properly.  */
2228
2229 #undef ASM_OUTPUT_FUNCTION_LABEL
2230 #define ASM_OUTPUT_FUNCTION_LABEL(FILE, NAME, DECL) \
2231   ix86_asm_output_function_label (FILE, NAME, DECL)
2232
2233 /* Under some conditions we need jump tables in the text section,
2234    because the assembler cannot handle label differences between
2235    sections.  This is the case for x86_64 on Mach-O for example.  */
2236
2237 #define JUMP_TABLES_IN_TEXT_SECTION \
2238   (flag_pic && ((TARGET_MACHO && TARGET_64BIT) \
2239    || (!TARGET_64BIT && !HAVE_AS_GOTOFF_IN_DATA)))
2240
2241 /* Switch to init or fini section via SECTION_OP, emit a call to FUNC,
2242    and switch back.  For x86 we do this only to save a few bytes that
2243    would otherwise be unused in the text section.  */
2244 #define CRT_MKSTR2(VAL) #VAL
2245 #define CRT_MKSTR(x) CRT_MKSTR2(x)
2246
2247 #define CRT_CALL_STATIC_FUNCTION(SECTION_OP, FUNC)              \
2248    asm (SECTION_OP "\n\t"                                       \
2249         "call " CRT_MKSTR(__USER_LABEL_PREFIX__) #FUNC "\n"     \
2250         TEXT_SECTION_ASM_OP);
2251
2252 /* Default threshold for putting data in large sections
2253    with x86-64 medium memory model */
2254 #define DEFAULT_LARGE_SECTION_THRESHOLD 65536
2255 \f
2256 /* Which processor to tune code generation for.  These must be in sync
2257    with processor_target_table in i386.c.  */ 
2258
2259 enum processor_type
2260 {
2261   PROCESSOR_GENERIC = 0,
2262   PROCESSOR_I386,                       /* 80386 */
2263   PROCESSOR_I486,                       /* 80486DX, 80486SX, 80486DX[24] */
2264   PROCESSOR_PENTIUM,
2265   PROCESSOR_PENTIUMPRO,
2266   PROCESSOR_PENTIUM4,
2267   PROCESSOR_NOCONA,
2268   PROCESSOR_CORE2,
2269   PROCESSOR_NEHALEM,
2270   PROCESSOR_SANDYBRIDGE,
2271   PROCESSOR_HASWELL,
2272   PROCESSOR_BONNELL,
2273   PROCESSOR_SILVERMONT,
2274   PROCESSOR_KNL,
2275   PROCESSOR_INTEL,
2276   PROCESSOR_GEODE,
2277   PROCESSOR_K6,
2278   PROCESSOR_ATHLON,
2279   PROCESSOR_K8,
2280   PROCESSOR_AMDFAM10,
2281   PROCESSOR_BDVER1,
2282   PROCESSOR_BDVER2,
2283   PROCESSOR_BDVER3,
2284   PROCESSOR_BDVER4,
2285   PROCESSOR_BTVER1,
2286   PROCESSOR_BTVER2,
2287   PROCESSOR_max
2288 };
2289
2290 extern enum processor_type ix86_tune;
2291 extern enum processor_type ix86_arch;
2292
2293 /* Size of the RED_ZONE area.  */
2294 #define RED_ZONE_SIZE 128
2295 /* Reserved area of the red zone for temporaries.  */
2296 #define RED_ZONE_RESERVE 8
2297
2298 extern unsigned int ix86_preferred_stack_boundary;
2299 extern unsigned int ix86_incoming_stack_boundary;
2300
2301 /* Smallest class containing REGNO.  */
2302 extern enum reg_class const regclass_map[FIRST_PSEUDO_REGISTER];
2303
2304 enum ix86_fpcmp_strategy {
2305   IX86_FPCMP_SAHF,
2306   IX86_FPCMP_COMI,
2307   IX86_FPCMP_ARITH
2308 };
2309 \f
2310 /* To properly truncate FP values into integers, we need to set i387 control
2311    word.  We can't emit proper mode switching code before reload, as spills
2312    generated by reload may truncate values incorrectly, but we still can avoid
2313    redundant computation of new control word by the mode switching pass.
2314    The fldcw instructions are still emitted redundantly, but this is probably
2315    not going to be noticeable problem, as most CPUs do have fast path for
2316    the sequence.
2317
2318    The machinery is to emit simple truncation instructions and split them
2319    before reload to instructions having USEs of two memory locations that
2320    are filled by this code to old and new control word.
2321
2322    Post-reload pass may be later used to eliminate the redundant fildcw if
2323    needed.  */
2324
2325 enum ix86_entity
2326 {
2327   AVX_U128 = 0,
2328   I387_TRUNC,
2329   I387_FLOOR,
2330   I387_CEIL,
2331   I387_MASK_PM,
2332   MAX_386_ENTITIES
2333 };
2334
2335 enum ix86_stack_slot
2336 {
2337   SLOT_TEMP = 0,
2338   SLOT_CW_STORED,
2339   SLOT_CW_TRUNC,
2340   SLOT_CW_FLOOR,
2341   SLOT_CW_CEIL,
2342   SLOT_CW_MASK_PM,
2343   MAX_386_STACK_LOCALS
2344 };
2345
2346 enum avx_u128_state
2347 {
2348   AVX_U128_CLEAN,
2349   AVX_U128_DIRTY,
2350   AVX_U128_ANY
2351 };
2352
2353 /* Define this macro if the port needs extra instructions inserted
2354    for mode switching in an optimizing compilation.  */
2355
2356 #define OPTIMIZE_MODE_SWITCHING(ENTITY) \
2357    ix86_optimize_mode_switching[(ENTITY)]
2358
2359 /* If you define `OPTIMIZE_MODE_SWITCHING', you have to define this as
2360    initializer for an array of integers.  Each initializer element N
2361    refers to an entity that needs mode switching, and specifies the
2362    number of different modes that might need to be set for this
2363    entity.  The position of the initializer in the initializer -
2364    starting counting at zero - determines the integer that is used to
2365    refer to the mode-switched entity in question.  */
2366
2367 #define NUM_MODES_FOR_MODE_SWITCHING \
2368   { AVX_U128_ANY, I387_CW_ANY, I387_CW_ANY, I387_CW_ANY, I387_CW_ANY }
2369
2370 \f
2371 /* Avoid renaming of stack registers, as doing so in combination with
2372    scheduling just increases amount of live registers at time and in
2373    the turn amount of fxch instructions needed.
2374
2375    ??? Maybe Pentium chips benefits from renaming, someone can try....
2376
2377    Don't rename evex to non-evex sse registers.  */
2378
2379 #define HARD_REGNO_RENAME_OK(SRC, TARGET) (!STACK_REGNO_P (SRC) &&       \
2380                                            (EXT_REX_SSE_REGNO_P (SRC) == \
2381                                             EXT_REX_SSE_REGNO_P (TARGET)))
2382
2383 \f
2384 #define FASTCALL_PREFIX '@'
2385 \f
2386 /* Machine specific frame tracking during prologue/epilogue generation.  */
2387
2388 #ifndef USED_FOR_TARGET
2389 struct GTY(()) machine_frame_state
2390 {
2391   /* This pair tracks the currently active CFA as reg+offset.  When reg
2392      is drap_reg, we don't bother trying to record here the real CFA when
2393      it might really be a DW_CFA_def_cfa_expression.  */
2394   rtx cfa_reg;
2395   HOST_WIDE_INT cfa_offset;
2396
2397   /* The current offset (canonically from the CFA) of ESP and EBP.
2398      When stack frame re-alignment is active, these may not be relative
2399      to the CFA.  However, in all cases they are relative to the offsets
2400      of the saved registers stored in ix86_frame.  */
2401   HOST_WIDE_INT sp_offset;
2402   HOST_WIDE_INT fp_offset;
2403
2404   /* The size of the red-zone that may be assumed for the purposes of
2405      eliding register restore notes in the epilogue.  This may be zero
2406      if no red-zone is in effect, or may be reduced from the real
2407      red-zone value by a maximum runtime stack re-alignment value.  */
2408   int red_zone_offset;
2409
2410   /* Indicate whether each of ESP, EBP or DRAP currently holds a valid
2411      value within the frame.  If false then the offset above should be
2412      ignored.  Note that DRAP, if valid, *always* points to the CFA and
2413      thus has an offset of zero.  */
2414   BOOL_BITFIELD sp_valid : 1;
2415   BOOL_BITFIELD fp_valid : 1;
2416   BOOL_BITFIELD drap_valid : 1;
2417
2418   /* Indicate whether the local stack frame has been re-aligned.  When
2419      set, the SP/FP offsets above are relative to the aligned frame
2420      and not the CFA.  */
2421   BOOL_BITFIELD realigned : 1;
2422 };
2423
2424 /* Private to winnt.c.  */
2425 struct seh_frame_state;
2426
2427 struct GTY(()) machine_function {
2428   struct stack_local_entry *stack_locals;
2429   const char *some_ld_name;
2430   int varargs_gpr_size;
2431   int varargs_fpr_size;
2432   int optimize_mode_switching[MAX_386_ENTITIES];
2433
2434   /* Number of saved registers USE_FAST_PROLOGUE_EPILOGUE
2435      has been computed for.  */
2436   int use_fast_prologue_epilogue_nregs;
2437
2438   /* For -fsplit-stack support: A stack local which holds a pointer to
2439      the stack arguments for a function with a variable number of
2440      arguments.  This is set at the start of the function and is used
2441      to initialize the overflow_arg_area field of the va_list
2442      structure.  */
2443   rtx split_stack_varargs_pointer;
2444
2445   /* This value is used for amd64 targets and specifies the current abi
2446      to be used. MS_ABI means ms abi. Otherwise SYSV_ABI means sysv abi.  */
2447   ENUM_BITFIELD(calling_abi) call_abi : 8;
2448
2449   /* Nonzero if the function accesses a previous frame.  */
2450   BOOL_BITFIELD accesses_prev_frame : 1;
2451
2452   /* Nonzero if the function requires a CLD in the prologue.  */
2453   BOOL_BITFIELD needs_cld : 1;
2454
2455   /* Set by ix86_compute_frame_layout and used by prologue/epilogue
2456      expander to determine the style used.  */
2457   BOOL_BITFIELD use_fast_prologue_epilogue : 1;
2458
2459   /* If true, the current function needs the default PIC register, not
2460      an alternate register (on x86) and must not use the red zone (on
2461      x86_64), even if it's a leaf function.  We don't want the
2462      function to be regarded as non-leaf because TLS calls need not
2463      affect register allocation.  This flag is set when a TLS call
2464      instruction is expanded within a function, and never reset, even
2465      if all such instructions are optimized away.  Use the
2466      ix86_current_function_calls_tls_descriptor macro for a better
2467      approximation.  */
2468   BOOL_BITFIELD tls_descriptor_call_expanded_p : 1;
2469
2470   /* If true, the current function has a STATIC_CHAIN is placed on the
2471      stack below the return address.  */
2472   BOOL_BITFIELD static_chain_on_stack : 1;
2473
2474   /* If true, it is safe to not save/restore DRAP register.  */
2475   BOOL_BITFIELD no_drap_save_restore : 1;
2476
2477   /* During prologue/epilogue generation, the current frame state.
2478      Otherwise, the frame state at the end of the prologue.  */
2479   struct machine_frame_state fs;
2480
2481   /* During SEH output, this is non-null.  */
2482   struct seh_frame_state * GTY((skip(""))) seh;
2483 };
2484 #endif
2485
2486 #define ix86_stack_locals (cfun->machine->stack_locals)
2487 #define ix86_varargs_gpr_size (cfun->machine->varargs_gpr_size)
2488 #define ix86_varargs_fpr_size (cfun->machine->varargs_fpr_size)
2489 #define ix86_optimize_mode_switching (cfun->machine->optimize_mode_switching)
2490 #define ix86_current_function_needs_cld (cfun->machine->needs_cld)
2491 #define ix86_tls_descriptor_calls_expanded_in_cfun \
2492   (cfun->machine->tls_descriptor_call_expanded_p)
2493 /* Since tls_descriptor_call_expanded is not cleared, even if all TLS
2494    calls are optimized away, we try to detect cases in which it was
2495    optimized away.  Since such instructions (use (reg REG_SP)), we can
2496    verify whether there's any such instruction live by testing that
2497    REG_SP is live.  */
2498 #define ix86_current_function_calls_tls_descriptor \
2499   (ix86_tls_descriptor_calls_expanded_in_cfun && df_regs_ever_live_p (SP_REG))
2500 #define ix86_static_chain_on_stack (cfun->machine->static_chain_on_stack)
2501
2502 /* Control behavior of x86_file_start.  */
2503 #define X86_FILE_START_VERSION_DIRECTIVE false
2504 #define X86_FILE_START_FLTUSED false
2505
2506 /* Flag to mark data that is in the large address area.  */
2507 #define SYMBOL_FLAG_FAR_ADDR            (SYMBOL_FLAG_MACH_DEP << 0)
2508 #define SYMBOL_REF_FAR_ADDR_P(X)        \
2509         ((SYMBOL_REF_FLAGS (X) & SYMBOL_FLAG_FAR_ADDR) != 0)
2510
2511 /* Flags to mark dllimport/dllexport.  Used by PE ports, but handy to
2512    have defined always, to avoid ifdefing.  */
2513 #define SYMBOL_FLAG_DLLIMPORT           (SYMBOL_FLAG_MACH_DEP << 1)
2514 #define SYMBOL_REF_DLLIMPORT_P(X) \
2515         ((SYMBOL_REF_FLAGS (X) & SYMBOL_FLAG_DLLIMPORT) != 0)
2516
2517 #define SYMBOL_FLAG_DLLEXPORT           (SYMBOL_FLAG_MACH_DEP << 2)
2518 #define SYMBOL_REF_DLLEXPORT_P(X) \
2519         ((SYMBOL_REF_FLAGS (X) & SYMBOL_FLAG_DLLEXPORT) != 0)
2520
2521 #define SYMBOL_FLAG_STUBVAR     (SYMBOL_FLAG_MACH_DEP << 4)
2522 #define SYMBOL_REF_STUBVAR_P(X) \
2523         ((SYMBOL_REF_FLAGS (X) & SYMBOL_FLAG_STUBVAR) != 0)
2524
2525 extern void debug_ready_dispatch (void);
2526 extern void debug_dispatch_window (int);
2527
2528 /* The value at zero is only defined for the BMI instructions
2529    LZCNT and TZCNT, not the BSR/BSF insns in the original isa.  */
2530 #define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) \
2531         ((VALUE) = GET_MODE_BITSIZE (MODE), TARGET_BMI ? 1 : 0)
2532 #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) \
2533         ((VALUE) = GET_MODE_BITSIZE (MODE), TARGET_LZCNT ? 1 : 0)
2534
2535
2536 /* Flags returned by ix86_get_callcvt ().  */
2537 #define IX86_CALLCVT_CDECL      0x1
2538 #define IX86_CALLCVT_STDCALL    0x2
2539 #define IX86_CALLCVT_FASTCALL   0x4
2540 #define IX86_CALLCVT_THISCALL   0x8
2541 #define IX86_CALLCVT_REGPARM    0x10
2542 #define IX86_CALLCVT_SSEREGPARM 0x20
2543
2544 #define IX86_BASE_CALLCVT(FLAGS) \
2545         ((FLAGS) & (IX86_CALLCVT_CDECL | IX86_CALLCVT_STDCALL \
2546                     | IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL))
2547
2548 #define RECIP_MASK_NONE         0x00
2549 #define RECIP_MASK_DIV          0x01
2550 #define RECIP_MASK_SQRT         0x02
2551 #define RECIP_MASK_VEC_DIV      0x04
2552 #define RECIP_MASK_VEC_SQRT     0x08
2553 #define RECIP_MASK_ALL  (RECIP_MASK_DIV | RECIP_MASK_SQRT \
2554                          | RECIP_MASK_VEC_DIV | RECIP_MASK_VEC_SQRT)
2555 #define RECIP_MASK_DEFAULT (RECIP_MASK_VEC_DIV | RECIP_MASK_VEC_SQRT)
2556
2557 #define TARGET_RECIP_DIV        ((recip_mask & RECIP_MASK_DIV) != 0)
2558 #define TARGET_RECIP_SQRT       ((recip_mask & RECIP_MASK_SQRT) != 0)
2559 #define TARGET_RECIP_VEC_DIV    ((recip_mask & RECIP_MASK_VEC_DIV) != 0)
2560 #define TARGET_RECIP_VEC_SQRT   ((recip_mask & RECIP_MASK_VEC_SQRT) != 0)
2561
2562 #define IX86_HLE_ACQUIRE (1 << 16)
2563 #define IX86_HLE_RELEASE (1 << 17)
2564
2565 /* For switching between functions with different target attributes.  */
2566 #define SWITCHABLE_TARGET 1
2567
2568 /*
2569 Local variables:
2570 version-control: t
2571 End:
2572 */