| blob | df76267a32b0132989a88fb69208f81f59483eb6 |
1 /* Machine description for AArch64 architecture.
2 Copyright (C) 2009-2015 Free Software Foundation, Inc.
3 Contributed by ARM Ltd.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GCC is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
100 /* Defined for convenience. */
101 #define POINTER_BYTES (POINTER_SIZE / BITS_PER_UNIT)
103 /* Classifies an address.
105 ADDRESS_REG_IMM
106 A simple base register plus immediate offset.
108 ADDRESS_REG_WB
109 A base register indexed by immediate offset with writeback.
111 ADDRESS_REG_REG
112 A base register indexed by (optionally scaled) register.
114 ADDRESS_REG_UXTW
115 A base register indexed by (optionally scaled) zero-extended register.
117 ADDRESS_REG_SXTW
118 A base register indexed by (optionally scaled) sign-extended register.
120 ADDRESS_LO_SUM
121 A LO_SUM rtx with a base register and "LO12" symbol relocation.
123 ADDRESS_SYMBOLIC:
124 A constant symbolic address, in pc-relative literal pool. */
127 ADDRESS_REG_IMM,
128 ADDRESS_REG_WB,
129 ADDRESS_REG_REG,
130 ADDRESS_REG_UXTW,
131 ADDRESS_REG_SXTW,
132 ADDRESS_LO_SUM,
133 ADDRESS_SYMBOLIC
134 };
138 rtx base;
139 rtx offset;
142 };
144 struct simd_immediate_info
145 {
146 rtx value;
151 };
153 /* The current code model. */
156 #ifdef HAVE_AS_TLS
157 #undef TARGET_HAVE_TLS
158 #define TARGET_HAVE_TLS 1
159 #endif
163 const_tree,
175 /* Major revision number of the ARM Architecture implemented by the target. */
178 /* The processor for which instructions should be scheduled. */
181 /* The current tuning set. */
184 /* Mask to specify which instructions we are allowed to generate. */
187 /* Mask to specify which instruction scheduling options should be used. */
190 /* Tuning parameters. */
193 {
194 {
199 },
205 };
208 {
209 {
214 },
220 };
223 {
224 {
229 },
235 };
238 {
240 /* Avoid the use of slow int<->fp moves for spilling by setting
241 their cost higher than memmov_cost. */
245 };
248 {
250 /* Avoid the use of slow int<->fp moves for spilling by setting
251 their cost higher than memmov_cost. */
255 };
258 {
260 /* Avoid the use of slow int<->fp moves for spilling by setting
261 their cost higher than memmov_cost. */
265 };
268 {
273 };
276 {
278 /* Avoid the use of slow int<->fp moves for spilling by setting
279 their cost higher than memmov_cost. */
283 };
285 /* Generic costs for vector insn classes. */
287 {
300 };
302 /* Generic costs for vector insn classes. */
304 {
317 };
319 /* Generic costs for vector insn classes. */
321 {
334 };
336 #define AARCH64_FUSE_NOTHING (0)
337 #define AARCH64_FUSE_MOV_MOVK (1 << 0)
338 #define AARCH64_FUSE_ADRP_ADD (1 << 1)
339 #define AARCH64_FUSE_MOVK_MOVK (1 << 2)
340 #define AARCH64_FUSE_ADRP_LDR (1 << 3)
341 #define AARCH64_FUSE_CMP_BRANCH (1 << 4)
344 {
358 };
361 {
376 };
379 {
394 };
397 {
411 };
414 {
428 };
430 /* A processor implementing AArch64. */
431 struct processor
432 {
439 };
441 /* Processor cores implementing AArch64. */
443 {
444 #define AARCH64_CORE(NAME, IDENT, SCHED, ARCH, FLAGS, COSTS, IMP, PART) \
445 {NAME, SCHED, #ARCH, ARCH, FLAGS, &COSTS##_tunings},
447 #undef AARCH64_CORE
450 };
452 /* Architectures implementing AArch64. */
454 {
455 #define AARCH64_ARCH(NAME, CORE, ARCH, FLAGS) \
456 {NAME, CORE, #ARCH, ARCH, FLAGS, NULL},
458 #undef AARCH64_ARCH
460 };
462 /* Target specification. These are populated as commandline arguments
463 are processed, or NULL if not specified. */
468 #define AARCH64_CPU_DEFAULT_FLAGS ((selected_cpu) ? selected_cpu->flags : 0)
470 /* An ISA extension in the co-processor and main instruction set space. */
471 struct aarch64_option_extension
472 {
476 };
478 /* ISA extensions in AArch64. */
480 {
481 #define AARCH64_OPT_EXTENSION(NAME, FLAGS_ON, FLAGS_OFF, FEATURE_STRING) \
482 {NAME, FLAGS_ON, FLAGS_OFF},
484 #undef AARCH64_OPT_EXTENSION
486 };
488 /* Used to track the size of an address when generating a pre/post
489 increment address. */
492 /* A table of valid AArch64 "bitmask immediate" values for
493 logical instructions. */
495 #define AARCH64_NUM_BITMASKS 5334
499 {
503 }
504 aarch64_cc;
506 #define AARCH64_INVERSE_CONDITION_CODE(X) ((aarch64_cc) (((int) X) ^ 1))
508 /* The condition codes of the processor, and the inverse function. */
510 {
513 };
515 static unsigned int
517 {
519 }
521 static int
524 {
532 }
534 /* Provide a mapping from gcc register numbers to dwarf register numbers. */
535 unsigned
537 {
545 /* Return values >= DWARF_FRAME_REGISTERS indicate that there is no
546 equivalent DWARF register. */
548 }
550 /* Return TRUE if MODE is any of the large INT modes. */
551 static bool
553 {
555 }
557 /* Return TRUE if MODE is any of the vector modes. */
558 static bool
560 {
563 }
565 /* Implement target hook TARGET_ARRAY_MODE_SUPPORTED_P. */
566 static bool
569 {
576 }
578 /* Implement HARD_REGNO_NREGS. */
580 int
582 {
584 {
590 }
592 }
594 /* Implement HARD_REGNO_MODE_OK. */
596 int
598 {
603 /* The purpose of comparing with ptr_mode is to support the
604 global register variable associated with the stack pointer
605 register via the syntax of asm ("wsp") in ILP32. */
615 {
617 return
619 else
621 }
624 }
626 /* Implement HARD_REGNO_CALLER_SAVE_MODE. */
627 machine_mode
629 machine_mode mode)
630 {
631 /* Handle modes that fit within single registers. */
633 {
636 else
638 }
639 /* Fall back to generic for multi-reg and very large modes. */
640 else
642 }
644 /* Return true if calls to DECL should be treated as
645 long-calls (ie called via a register). */
646 static bool
648 {
650 }
652 /* Return true if calls to symbol-ref SYM should be treated as
653 long-calls (ie called via a register). */
654 bool
656 {
658 }
660 /* Return true if the offsets to a zero/sign-extract operation
661 represent an expression that matches an extend operation. The
662 operands represent the paramters from
664 (extract:MODE (mult (reg) (MULT_IMM)) (EXTRACT_IMM) (const_int 0)). */
665 bool
667 rtx extract_imm)
668 {
685 }
687 /* Emit an insn that's a simple single-set. Both the operands must be
688 known to be valid. */
691 {
693 }
695 /* X and Y are two things to compare using CODE. Emit the compare insn and
696 return the rtx for register 0 in the proper mode. */
697 rtx
699 {
705 }
707 /* Build the SYMBOL_REF for __tls_get_addr. */
711 rtx
713 {
717 }
719 /* Return the TLS model to use for ADDR. */
721 static enum tls_model
723 {
728 {
732 }
737 }
739 /* We'll allow lo_sum's in addresses in our legitimate addresses
740 so that combine would take care of combining addresses where
741 necessary, but for generation purposes, we'll generate the address
742 as :
743 RTL Absolute
744 tmp = hi (symbol_ref); adrp x1, foo
745 dest = lo_sum (tmp, symbol_ref); add dest, x1, :lo_12:foo
746 nop
748 PIC TLS
749 adrp x1, :got:foo adrp tmp, :tlsgd:foo
750 ldr x1, [:got_lo12:foo] add dest, tmp, :tlsgd_lo12:foo
751 bl __tls_get_addr
752 nop
754 Load TLS symbol, depending on TLS mechanism and TLS access model.
756 Global Dynamic - Traditional TLS:
757 adrp tmp, :tlsgd:imm
758 add dest, tmp, #:tlsgd_lo12:imm
759 bl __tls_get_addr
761 Global Dynamic - TLS Descriptors:
762 adrp dest, :tlsdesc:imm
763 ldr tmp, [dest, #:tlsdesc_lo12:imm]
764 add dest, dest, #:tlsdesc_lo12:imm
765 blr tmp
766 mrs tp, tpidr_el0
767 add dest, dest, tp
769 Initial Exec:
770 mrs tp, tpidr_el0
771 adrp tmp, :gottprel:imm
772 ldr dest, [tmp, #:gottprel_lo12:imm]
773 add dest, dest, tp
775 Local Exec:
776 mrs tp, tpidr_el0
777 add t0, tp, #:tprel_hi12:imm, lsl #12
778 add t0, t0, #:tprel_lo12_nc:imm
779 */
781 static void
784 {
786 {
788 {
789 /* In ILP32, the mode of dest can be either SImode or DImode. */
801 }
808 {
809 /* In ILP32, the mode of dest can be either SImode or DImode,
810 while the got entry is always of SImode size. The mode of
811 dest depends on how dest is used: if dest is assigned to a
812 pointer (e.g. in the memory), it has SImode; it may have
813 DImode if dest is dereferenced to access the memeory.
814 This is why we have to handle three different ldr_got_small
815 patterns here (two patterns for ILP32). */
824 {
827 else
829 }
830 else
831 {
834 }
837 }
840 {
852 }
855 {
858 rtx tp;
862 /* In ILP32, the got entry is always of SImode size. Unlike
863 small GOT, the dest is fixed at reg 0. */
866 else
876 }
879 {
880 /* In ILP32, the mode of dest can be either SImode or DImode,
881 while the got entry is always of SImode size. The mode of
882 dest depends on how dest is used: if dest is assigned to a
883 pointer (e.g. in the memory), it has SImode; it may have
884 DImode if dest is dereferenced to access the memeory.
885 This is why we have to handle three different tlsie_small
886 patterns here (two patterns for ILP32). */
892 {
895 else
896 {
899 }
900 }
901 else
902 {
905 }
910 }
913 {
922 }
930 }
931 }
933 /* Emit a move from SRC to DEST. Assume that the move expanders can
934 handle all moves if !can_create_pseudo_p (). The distinction is
935 important because, unlike emit_move_insn, the move expanders know
936 how to force Pmode objects into the constant pool even when the
937 constant pool address is not itself legitimate. */
938 static rtx
940 {
944 }
946 /* Split a 128-bit move operation into two 64-bit move operations,
947 taking care to handle partial overlap of register to register
948 copies. Special cases are needed when moving between GP regs and
949 FP regs. SRC can be a register, constant or memory; DST a register
950 or memory. If either operand is memory it must not have any side
951 effects. */
952 void
954 {
965 {
969 /* Handle FP <-> GP regs. */
971 {
976 {
979 }
980 else
981 {
984 }
986 }
988 {
993 {
996 }
997 else
998 {
1001 }
1003 }
1004 }
1011 /* At most one pairing may overlap. */
1013 {
1016 }
1017 else
1018 {
1021 }
1022 }
1024 bool
1026 {
1029 }
1031 /* Split a complex SIMD combine. */
1033 void
1035 {
1042 {
1046 {
1067 }
1071 }
1072 }
1074 /* Split a complex SIMD move. */
1076 void
1078 {
1085 {
1091 {
1112 }
1116 }
1117 }
1119 static rtx
1121 {
1124 else
1125 {
1128 }
1129 }
1132 static rtx
1134 {
1136 {
1137 rtx high;
1138 /* Load the full offset into a register. This
1139 might be improvable in the future. */
1145 }
1147 }
1149 static int
1151 machine_mode mode)
1152 {
1158 rtx subtarget;
1163 {
1166 num_insns++;
1168 }
1171 {
1172 /* We know we can't do this in 1 insn, and we must be able to do it
1173 in two; so don't mess around looking for sequences that don't buy
1174 us anything. */
1176 {
1181 }
1184 }
1186 /* Remaining cases are all for DImode. */
1197 {
1199 one_match++;
1200 else
1201 {
1205 zero_match++;
1206 }
1207 }
1210 {
1211 /* Set one of the quarters and then insert back into result. */
1214 {
1219 }
1222 }
1229 {
1233 {
1235 {
1241 }
1244 }
1246 {
1248 {
1254 }
1257 }
1259 {
1261 {
1267 }
1270 }
1272 {
1274 {
1280 }
1283 }
1284 }
1286 /* See if we can do it by arithmetically combining two
1287 immediates. */
1289 {
1295 {
1297 {
1303 }
1306 }
1309 {
1311 {
1313 {
1318 }
1321 }
1322 }
1323 }
1325 /* See if we can do it by logically combining two immediates. */
1327 {
1329 {
1334 {
1336 {
1342 }
1345 }
1346 }
1348 {
1353 {
1355 {
1361 }
1364 }
1365 }
1366 }
1369 {
1370 /* Set either first three quarters or all but the third. */
1375 num_insns ++;
1377 /* Now insert other two quarters. */
1380 {
1382 {
1386 num_insns ++;
1387 }
1388 }
1390 }
1392 simple_sequence:
1396 {
1398 {
1400 {
1404 num_insns ++;
1406 }
1407 else
1408 {
1412 num_insns ++;
1413 }
1414 }
1415 }
1418 }
1421 void
1423 {
1428 /* Check on what type of symbol it is. */
1432 {
1436 /* If we have (const (plus symbol offset)), separate out the offset
1437 before we start classifying the symbol. */
1442 {
1446 {
1452 }
1466 {
1472 }
1473 /* FALLTHRU */
1483 }
1484 }
1487 {
1490 else
1491 {
1495 }
1498 }
1501 }
1503 static bool
1505 tree exp ATTRIBUTE_UNUSED)
1506 {
1507 /* Currently, always true. */
1509 }
1511 /* Implement TARGET_PASS_BY_REFERENCE. */
1513 static bool
1515 machine_mode mode,
1516 const_tree type,
1518 {
1519 HOST_WIDE_INT size;
1520 machine_mode dummymode;
1523 /* GET_MODE_SIZE (BLKmode) is useless since it is 0. */
1527 /* Aggregates are passed by reference based on their size. */
1529 {
1531 }
1533 /* Variable sized arguments are always returned by reference. */
1537 /* Can this be a candidate to be passed in fp/simd register(s)? */
1540 NULL))
1543 /* Arguments which are variable sized or larger than 2 registers are
1544 passed by reference unless they are a homogenous floating point
1545 aggregate. */
1547 }
1549 /* Return TRUE if VALTYPE is padded to its least significant bits. */
1550 static bool
1552 {
1553 machine_mode dummy_mode;
1556 /* Never happens in little-endian mode. */
1560 /* Only composite types smaller than or equal to 16 bytes can
1561 be potentially returned in registers. */
1567 /* But not a composite that is an HFA (Homogeneous Floating-point Aggregate)
1568 or an HVA (Homogeneous Short-Vector Aggregate); such a special composite
1569 is always passed/returned in the least significant bits of fp/simd
1570 register(s). */
1576 }
1578 /* Implement TARGET_FUNCTION_VALUE.
1579 Define how to find the value returned by a function. */
1581 static rtx
1584 {
1585 machine_mode mode;
1588 machine_mode ag_mode;
1595 {
1599 {
1602 }
1603 }
1607 {
1609 {
1612 }
1613 else
1614 {
1616 rtx par;
1620 {
1625 }
1627 }
1628 }
1629 else
1631 }
1633 /* Implements TARGET_FUNCTION_VALUE_REGNO_P.
1634 Return true if REGNO is the number of a hard register in which the values
1635 of called function may come back. */
1637 static bool
1639 {
1640 /* Maximum of 16 bytes can be returned in the general registers. Examples
1641 of 16-byte return values are: 128-bit integers and 16-byte small
1642 structures (excluding homogeneous floating-point aggregates). */
1646 /* Up to four fp/simd registers can return a function value, e.g. a
1647 homogeneous floating-point aggregate having four members. */
1652 }
1654 /* Implement TARGET_RETURN_IN_MEMORY.
1656 If the type T of the result of a function is such that
1657 void func (T arg)
1658 would require that arg be passed as a value in a register (or set of
1659 registers) according to the parameter passing rules, then the result
1660 is returned in the same registers as would be used for such an
1661 argument. */
1663 static bool
1665 {
1666 HOST_WIDE_INT size;
1667 machine_mode ag_mode;
1673 /* Simple scalar types always returned in registers. */
1677 type,
1680 NULL))
1683 /* Types larger than 2 registers returned in memory. */
1686 }
1688 static bool
1691 {
1694 type,
1696 nregs,
1697 NULL);
1698 }
1700 /* Given MODE and TYPE of a function argument, return the alignment in
1701 bits. The idea is to suppress any stronger alignment requested by
1702 the user and opt for the natural alignment (specified in AAPCS64 \S 4.1).
1703 This is a helper function for local use only. */
1705 static unsigned int
1707 {
1711 {
1713 {
1716 else
1718 }
1719 else
1721 }
1722 else
1726 }
1728 /* Layout a function argument according to the AAPCS64 rules. The rule
1729 numbers refer to the rule numbers in the AAPCS64. */
1731 static void
1733 const_tree type,
1735 {
1739 HOST_WIDE_INT size;
1741 /* We need to do this once per argument. */
1747 /* Size in bytes, rounded to the nearest multiple of 8 bytes. */
1748 size
1750 UNITS_PER_WORD);
1754 mode,
1755 type,
1758 /* allocate_ncrn may be false-positive, but allocate_nvrn is quite reliable.
1759 The following code thus handles passing by SIMD/FP registers first. */
1763 /* C1 - C5 for floating point, homogenous floating point aggregates (HFA)
1764 and homogenous short-vector aggregates (HVA). */
1766 {
1768 {
1771 {
1774 }
1775 else
1776 {
1777 rtx par;
1781 {
1784 tmp = gen_rtx_EXPR_LIST
1788 }
1790 }
1792 }
1793 else
1794 {
1795 /* C.3 NSRN is set to 8. */
1798 }
1799 }
1804 /* C6 - C9. though the sign and zero extension semantics are
1805 handled elsewhere. This is the case where the argument fits
1806 entirely general registers. */
1808 {
1813 /* C.8 if the argument has an alignment of 16 then the NGRN is
1814 rounded up to the next even number. */
1816 {
1819 }
1820 /* NREGS can be 0 when e.g. an empty structure is to be passed.
1821 A reg is still generated for it, but the caller should be smart
1822 enough not to use it. */
1824 {
1826 }
1827 else
1828 {
1829 rtx par;
1834 {
1839 }
1841 }
1845 }
1847 /* C.11 */
1850 /* The argument is passed on stack; record the needed number of words for
1851 this argument and align the total size if necessary. */
1852 on_stack:
1858 }
1860 /* Implement TARGET_FUNCTION_ARG. */
1862 static rtx
1865 {
1874 }
1876 void
1878 const_tree fntype ATTRIBUTE_UNUSED,
1879 rtx libname ATTRIBUTE_UNUSED,
1880 const_tree fndecl ATTRIBUTE_UNUSED,
1882 {
1894 }
1896 static void
1898 machine_mode mode,
1899 const_tree type,
1901 {
1904 {
1914 }
1915 }
1917 bool
1919 {
1922 }
1924 /* Implement FUNCTION_ARG_BOUNDARY. Every parameter gets at least
1925 PARM_BOUNDARY bits of alignment, but will be given anything up
1926 to STACK_BOUNDARY bits if the type requires it. This makes sure
1927 that both before and after the layout of each argument, the Next
1928 Stacked Argument Address (NSAA) will have a minimum alignment of
1929 8 bytes. */
1931 static unsigned int
1933 {
1941 }
1943 /* For use by FUNCTION_ARG_PADDING (MODE, TYPE).
1945 Return true if an argument passed on the stack should be padded upwards,
1946 i.e. if the least-significant byte of the stack slot has useful data.
1948 Small aggregate types are placed in the lowest memory address.
1950 The related parameter passing rules are B.4, C.3, C.5 and C.14. */
1952 bool
1954 {
1955 /* On little-endian targets, the least significant byte of every stack
1956 argument is passed at the lowest byte address of the stack slot. */
1960 /* Otherwise, integral, floating-point and pointer types are padded downward:
1961 the least significant byte of a stack argument is passed at the highest
1962 byte address of the stack slot. */
1969 /* Everything else padded upward, i.e. data in first byte of stack slot. */
1971 }
1973 /* Similarly, for use by BLOCK_REG_PADDING (MODE, TYPE, FIRST).
1975 It specifies padding for the last (may also be the only)
1976 element of a block move between registers and memory. If
1977 assuming the block is in the memory, padding upward means that
1978 the last element is padded after its highest significant byte,
1979 while in downward padding, the last element is padded at the
1980 its least significant byte side.
1982 Small aggregates and small complex types are always padded
1983 upwards.
1985 We don't need to worry about homogeneous floating-point or
1986 short-vector aggregates; their move is not affected by the
1987 padding direction determined here. Regardless of endianness,
1988 each element of such an aggregate is put in the least
1989 significant bits of a fp/simd register.
1991 Return !BYTES_BIG_ENDIAN if the least significant byte of the
1992 register has useful data, and return the opposite if the most
1993 significant byte does. */
1995 bool
1998 {
2000 /* Small composite types are always padded upward. */
2002 {
2007 }
2009 /* Otherwise, use the default padding. */
2011 }
2013 static machine_mode
2015 {
2017 }
2019 static bool
2021 {
2022 /* In aarch64_override_options_after_change
2023 flag_omit_leaf_frame_pointer turns off the frame pointer by
2024 default. Turn it back on now if we've not got a leaf
2025 function. */
2031 }
2033 /* Mark the registers that need to be saved by the callee and calculate
2034 the size of the callee-saved registers area and frame record (both FP
2035 and LR may be omitted). */
2036 static void
2038 {
2045 #define SLOT_NOT_REQUIRED (-2)
2046 #define SLOT_REQUIRED (-1)
2051 /* First mark all the registers that really need to be saved... */
2058 /* ... that includes the eh data registers (if needed)... */
2064 /* ... and any callee saved register that dataflow says is live. */
2077 {
2078 /* FP and LR are placed in the linkage record. */
2085 }
2087 /* Now assign stack slots for them. */
2090 {
2097 }
2101 {
2109 }
2129 }
2131 static bool
2133 {
2135 }
2137 static unsigned
2139 {
2141 regno ++;
2143 }
2145 static void
2147 HOST_WIDE_INT adjustment)
2148 {
2159 }
2161 static rtx
2163 HOST_WIDE_INT adjustment)
2164 {
2166 {
2177 }
2178 }
2180 static void
2183 {
2193 }
2195 static rtx
2197 HOST_WIDE_INT adjustment)
2198 {
2200 {
2209 }
2210 }
2212 static rtx
2214 rtx reg2)
2215 {
2217 {
2226 }
2227 }
2229 static rtx
2231 rtx mem2)
2232 {
2234 {
2243 }
2244 }
2247 static void
2250 {
2260 {
2262 HOST_WIDE_INT offset;
2272 offset));
2280 {
2282 rtx mem2;
2286 offset));
2288 reg2));
2290 /* The first part of a frame-related parallel insn is
2291 always assumed to be relevant to the frame
2292 calculations; subsequent parts, are only
2293 frame-related if explicitly marked. */
2296 }
2297 else
2301 }
2302 }
2304 static void
2308 {
2314 HOST_WIDE_INT offset;
2319 {
2336 {
2338 rtx mem2;
2346 }
2347 else
2350 }
2351 }
2353 /* AArch64 stack frames generated by this compiler look like:
2355 +-------------------------------+
2356 | |
2357 | incoming stack arguments |
2358 | |
2359 +-------------------------------+
2360 | | <-- incoming stack pointer (aligned)
2361 | callee-allocated save area |
2362 | for register varargs |
2363 | |
2364 +-------------------------------+
2365 | local variables | <-- frame_pointer_rtx
2366 | |
2367 +-------------------------------+
2368 | padding0 | \
2369 +-------------------------------+ |
2370 | callee-saved registers | | frame.saved_regs_size
2371 +-------------------------------+ |
2372 | LR' | |
2373 +-------------------------------+ |
2374 | FP' | / <- hard_frame_pointer_rtx (aligned)
2375 +-------------------------------+
2376 | dynamic allocation |
2377 +-------------------------------+
2378 | padding |
2379 +-------------------------------+
2380 | outgoing stack arguments | <-- arg_pointer
2381 | |
2382 +-------------------------------+
2383 | | <-- stack_pointer_rtx (aligned)
2385 Dynamic stack allocations via alloca() decrease stack_pointer_rtx
2386 but leave frame_pointer_rtx and hard_frame_pointer_rtx
2387 unchanged. */
2389 /* Generate the prologue instructions for entry into a function.
2390 Establish the stack frame by decreasing the stack pointer with a
2391 properly calculated size and, if necessary, create a frame record
2392 filled with the values of LR and previous frame pointer. The
2393 current FP is also set up if it is in use. */
2395 void
2397 {
2398 /* sub sp, sp, #<frame_size>
2399 stp {fp, lr}, [sp, #<frame_size> - 16]
2400 add fp, sp, #<frame_size> - hardfp_offset
2401 stp {cs_reg}, [fp, #-16] etc.
2403 sub sp, sp, <final_adjustment_if_any>
2404 */
2407 HOST_WIDE_INT hard_fp_offset;
2419 /* Store pairs and load pairs have a range only -512 to 504. */
2421 {
2422 /* When the frame has a large size, an initial decrease is done on
2423 the stack pointer to jump over the callee-allocated save area for
2424 register varargs, the local variable area and/or the callee-saved
2425 register area. This will allow the pre-index write-back
2426 store pair instructions to be used for setting up the stack frame
2427 efficiently. */
2436 {
2446 }
2448 {
2453 {
2457 }
2459 {
2463 }
2464 }
2465 }
2466 else
2470 {
2474 {
2478 {
2485 }
2486 else
2489 /* Set up frame pointer to point to the location of the
2490 previous frame pointer on the stack. */
2492 stack_pointer_rtx,
2496 }
2497 else
2498 {
2506 {
2510 }
2511 else
2512 {
2519 else
2521 }
2522 }
2525 skip_wb);
2527 skip_wb);
2528 }
2530 /* when offset >= 512,
2531 sub sp, sp, #<outgoing_args_size> */
2533 {
2535 {
2540 }
2541 }
2542 }
2544 /* Return TRUE if we can use a simple_return insn.
2546 This function checks whether the callee saved stack is empty, which
2547 means no restore actions are need. The pro_and_epilogue will use
2548 this to check whether shrink-wrapping opt is feasible. */
2550 bool
2552 {
2562 }
2564 /* Generate the epilogue instructions for returning from a function. */
2565 void
2567 {
2569 HOST_WIDE_INT fp_offset;
2570 HOST_WIDE_INT hard_fp_offset;
2572 /* We need to add memory barrier to prevent read from deallocated stack. */
2582 /* Store pairs and load pairs have a range only -512 to 504. */
2584 {
2592 {
2597 }
2598 }
2599 else
2602 /* If there were outgoing arguments or we've done dynamic stack
2603 allocation, then restore the stack pointer from the frame
2604 pointer. This is at most one insn and more efficient than using
2605 GCC's internal mechanism. */
2608 {
2613 hard_frame_pointer_rtx,
2616 }
2619 {
2642 {
2648 {
2653 }
2654 else
2655 {
2662 }
2663 }
2664 else
2665 {
2668 }
2670 /* Reset the CFA to be SP + FRAME_SIZE. */
2677 }
2680 {
2685 {
2689 }
2690 else
2691 {
2696 {
2701 }
2704 }
2706 /* Reset the CFA to be SP + 0. */
2709 }
2711 /* Stack adjustment for exception handler. */
2713 {
2714 /* We need to unwind the stack by the offset computed by
2715 EH_RETURN_STACKADJ_RTX. We have already reset the CFA
2716 to be SP; letting the CFA move during this adjustment
2717 is just as correct as retaining the CFA from the body
2718 of the function. Therefore, do nothing special. */
2720 }
2725 }
2727 /* Return the place to copy the exception unwinding return address to.
2728 This will probably be a stack slot, but could (in theory be the
2729 return register). */
2730 rtx
2732 {
2733 HOST_WIDE_INT fp_offset;
2743 /* DSE and CSELIB do not detect an alias between sp+k1 and fp+k2. This can
2744 result in a store to save LR introduced by builtin_eh_return () being
2745 incorrectly deleted because the alias is not detected.
2746 So in the calculation of the address to copy the exception unwinding
2747 return address to, we note 2 cases.
2748 If FP is needed and the fp_offset is 0, it means that SP = FP and hence
2749 we return a SP-relative location since all the addresses are SP-relative
2750 in this case. This prevents the store from being optimized away.
2751 If the fp_offset is not 0, then the addresses will be FP-relative and
2752 therefore we return a FP-relative location. */
2755 {
2759 else
2762 }
2764 /* If FP is not needed, we calculate the location of LR, which would be
2765 at the top of the saved registers block. */
2769 stack_pointer_rtx,
2770 fp_offset
2773 }
2775 /* Possibly output code to build up a constant in a register. For
2776 the benefit of the costs infrastructure, returns the number of
2777 instructions which would be emitted. GENERATE inhibits or
2778 enables code generation. */
2780 static int
2782 {
2786 {
2790 }
2791 else
2792 {
2797 HOST_WIDE_INT valm;
2798 HOST_WIDE_INT tval;
2801 {
2811 }
2813 /* zcount contains the number of additional MOVK instructions
2814 required if the constant is built up with an initial MOVZ instruction,
2815 while ncount is the number of MOVK instructions required if starting
2816 with a MOVN instruction. Choose the sequence that yields the fewest
2817 number of instructions, preferring MOVZ instructions when they are both
2818 the same. */
2820 {
2825 insns++;
2826 }
2827 else
2828 {
2833 insns++;
2834 }
2839 {
2841 {
2846 insns++;
2847 }
2849 }
2850 }
2852 }
2854 static void
2856 {
2865 {
2868 }
2870 {
2872 {
2878 else
2881 }
2883 {
2887 }
2888 }
2889 }
2891 /* Output code to add DELTA to the first argument, and then jump
2892 to FUNCTION. Used for C++ multiple inheritance. */
2893 static void
2895 HOST_WIDE_INT delta,
2896 HOST_WIDE_INT vcall_offset,
2897 tree function)
2898 {
2899 /* The this pointer is always in x0. Note that this differs from
2900 Arm where the this pointer maybe bumped to r1 if r0 is required
2901 to return a pointer to an aggregate. On AArch64 a result value
2902 pointer will be in x8. */
2912 else
2913 {
2922 {
2926 else
2928 }
2932 else
2939 else
2940 {
2943 }
2947 else
2953 }
2955 /* Generate a tail call to the target function. */
2957 {
2960 }
2972 /* Stop pretending to be a post-reload pass. */
2974 }
2976 static bool
2978 {
2983 {
2987 /* Don't recurse into UNSPEC_TLS looking for TLS symbols; these are
2988 TLS offsets, not real symbol references. */
2991 }
2993 }
2996 static int
2998 {
3007 }
3010 static void
3012 {
3018 {
3022 else
3025 {
3027 {
3028 /* set s consecutive bits to 1 (s < 64) */
3030 /* rotate right by r */
3033 /* replicate the constant depending on SIMD size */
3044 }
3047 }
3048 }
3049 }
3053 aarch64_bitmasks_cmp);
3054 }
3057 /* Return true if val can be encoded as a 12-bit unsigned immediate with
3058 a left shift of 0 or 12 bits. */
3059 bool
3061 {
3064 );
3065 }
3068 /* Return true if val is an immediate that can be loaded into a
3069 register by a MOVZ instruction. */
3070 static bool
3072 {
3074 {
3078 }
3079 else
3080 {
3081 /* Ignore sign extension. */
3083 }
3086 }
3089 /* Return true if val is a valid bitmask immediate. */
3090 bool
3092 {
3094 {
3095 /* Replicate bit pattern. */
3098 }
3101 }
3104 /* Return true if val is an immediate that can be loaded into a
3105 register in a single instruction. */
3106 bool
3108 {
3112 }
3114 static bool
3116 {
3124 {
3128 else
3129 /* Avoid generating a 64-bit relocation in ILP32; leave
3130 to aarch64_expand_mov_immediate to handle it properly. */
3132 }
3135 }
3137 /* Return true if register REGNO is a valid index register.
3138 STRICT_P is true if REG_OK_STRICT is in effect. */
3140 bool
3142 {
3144 {
3152 }
3154 }
3156 /* Return true if register REGNO is a valid base register for mode MODE.
3157 STRICT_P is true if REG_OK_STRICT is in effect. */
3159 bool
3161 {
3163 {
3171 }
3173 /* The fake registers will be eliminated to either the stack or
3174 hard frame pointer, both of which are usually valid base registers.
3175 Reload deals with the cases where the eliminated form isn't valid. */
3180 }
3182 /* Return true if X is a valid base register for mode MODE.
3183 STRICT_P is true if REG_OK_STRICT is in effect. */
3185 static bool
3187 {
3192 }
3194 /* Return true if address offset is a valid index. If it is, fill in INFO
3195 appropriately. STRICT_P is true if REG_OK_STRICT is in effect. */
3197 static bool
3200 {
3202 rtx index;
3205 /* (reg:P) */
3208 {
3212 }
3213 /* (sign_extend:DI (reg:SI)) */
3218 {
3223 }
3224 /* (mult:DI (sign_extend:DI (reg:SI)) (const_int scale)) */
3231 {
3236 }
3237 /* (ashift:DI (sign_extend:DI (reg:SI)) (const_int shift)) */
3244 {
3249 }
3250 /* (sign_extract:DI (mult:DI (reg:DI) (const_int scale)) 32+shift 0) */
3257 {
3265 }
3266 /* (and:DI (mult:DI (reg:DI) (const_int scale))
3267 (const_int 0xffffffff<<shift)) */
3274 {
3280 }
3281 /* (sign_extract:DI (ashift:DI (reg:DI) (const_int shift)) 32+shift 0) */
3288 {
3296 }
3297 /* (and:DI (ashift:DI (reg:DI) (const_int shift))
3298 (const_int 0xffffffff<<shift)) */
3305 {
3311 }
3312 /* (mult:P (reg:P) (const_int scale)) */
3317 {
3321 }
3322 /* (ashift:P (reg:P) (const_int shift)) */
3327 {
3331 }
3332 else
3343 {
3348 }
3351 }
3353 bool
3355 {
3359 }
3363 HOST_WIDE_INT offset)
3364 {
3366 }
3370 {
3374 }
3376 /* Return true if X is a valid address for machine mode MODE. If it is,
3377 fill in INFO appropriately. STRICT_P is true if REG_OK_STRICT is in
3378 effect. OUTER_CODE is PARALLEL for a load/store pair. */
3380 static bool
3384 {
3388 /* On BE, we use load/store pair for all large int mode load/stores. */
3390 || (BYTES_BIG_ENDIAN
3394 !load_store_pair_p
3398 /* On LE, for AdvSIMD, don't support anything other than POST_INC or
3399 REG addressing. */
3405 {
3423 {
3429 }
3434 {
3441 /* TImode and TFmode values are allowed in both pairs of X
3442 registers and individual Q registers. The available
3443 address modes are:
3444 X,X: 7-bit signed scaled offset
3445 Q: 9-bit signed offset
3446 We conservatively require an offset representable in either mode.
3447 */
3452 /* A 7bit offset check because OImode will emit a ldp/stp
3453 instruction (only big endian will get here).
3454 For ldp/stp instructions, the offset is scaled for the size of a
3455 single element of the pair. */
3459 /* Three 9/12 bit offsets checks because CImode will emit three
3460 ldr/str instructions (only big endian will get here). */
3467 /* Two 7bit offsets checks because XImode will emit two ldp/stp
3468 instructions (only big endian will get here). */
3477 else
3480 }
3483 {
3484 /* Look for base + (scaled/extended) index register. */
3487 {
3490 }
3493 {
3496 }
3497 }
3518 {
3519 HOST_WIDE_INT offset;
3523 /* TImode and TFmode values are allowed in both pairs of X
3524 registers and individual Q registers. The available
3525 address modes are:
3526 X,X: 7-bit signed scaled offset
3527 Q: 9-bit signed offset
3528 We conservatively require an offset representable in either mode.
3529 */
3537 else
3539 }
3545 /* load literal: pc-relative constant pool entry. Only supported
3546 for SI mode or larger. */
3550 {
3557 }
3566 {
3572 {
3573 /* The symbol and offset must be aligned to the access size. */
3580 {
3584 }
3590 else
3599 }
3600 }
3605 }
3606 }
3608 bool
3610 {
3611 rtx offset;
3615 }
3617 /* Classify the base of symbolic expression X, given that X appears in
3618 context CONTEXT. */
3620 enum aarch64_symbol_type
3623 {
3624 rtx offset;
3628 }
3631 /* Return TRUE if X is a legitimate address for accessing memory in
3632 mode MODE. */
3633 static bool
3635 {
3639 }
3641 /* Return TRUE if X is a legitimate address for accessing memory in
3642 mode MODE. OUTER_CODE will be PARALLEL if this is a load/store
3643 pair operation. */
3644 bool
3647 {
3651 }
3653 /* Return TRUE if rtx X is immediate constant 0.0 */
3654 bool
3656 {
3657 REAL_VALUE_TYPE r;
3666 }
3668 /* Return the fixed registers used for condition codes. */
3670 static bool
3672 {
3676 }
3678 /* Emit call insn with PAT and do aarch64-specific handling. */
3680 void
3682 {
3688 }
3690 machine_mode
3692 {
3693 /* All floating point compares return CCFP if it is an equality
3694 comparison, and CCFPE otherwise. */
3696 {
3698 {
3719 }
3720 }
3729 /* A compare with a shifted operand. Because of canonicalization,
3730 the comparison will have to be swapped when we emit the assembly
3731 code. */
3739 /* Similarly for a negated operand, but we can only do this for
3740 equalities. */
3747 /* A compare of a mode narrower than SI mode against zero can be done
3748 by extending the value in the comparison. */
3751 /* Only use sign-extension if we really need it. */
3755 /* For everything else, return CCmode. */
3757 }
3759 static int
3762 int
3764 {
3771 }
3773 static int
3775 {
3778 {
3782 {
3796 }
3851 {
3863 }
3870 {
3882 }
3887 {
3893 }
3898 {
3902 }
3908 }
3917 }
3919 bool
3921 HOST_WIDE_INT minval,
3922 HOST_WIDE_INT maxval)
3923 {
3924 HOST_WIDE_INT firstval;
3941 }
3943 bool
3945 {
3947 }
3949 static unsigned
3951 {
3955 {
3956 count++;
3958 }
3961 }
3963 /* N Z C V. */
3964 #define AARCH64_CC_V 1
3965 #define AARCH64_CC_C (1 << 1)
3966 #define AARCH64_CC_Z (1 << 2)
3967 #define AARCH64_CC_N (1 << 3)
3969 /* N Z C V flags for ccmp. The first code is for AND op and the other
3970 is for IOR op. Indexed by AARCH64_COND_CODE. */
3972 {
3989 };
3991 int
3993 {
3995 {
4028 }
4029 }
4032 void
4034 {
4036 {
4037 /* An integer or symbol address without a preceding # sign. */
4040 {
4052 {
4055 }
4056 /* Fall through. */
4060 }
4064 /* Print the sign/zero-extend size as a character 8->b, 16->h, 32->w. */
4065 {
4070 {
4073 }
4076 {
4089 }
4090 }
4094 {
4097 /* Print N such that 2^N == X. */
4099 {
4102 }
4105 }
4109 /* Print the number of non-zero bits in X (a const_int). */
4111 {
4114 }
4120 /* Print the higher numbered register of a pair (TImode) of regs. */
4122 {
4125 }
4131 {
4133 /* Print a condition (eq, ne, etc). */
4135 /* CONST_TRUE_RTX means always -- that's the default. */
4140 {
4143 }
4148 }
4152 {
4154 /* Print the inverse of a condition (eq <-> ne, etc). */
4156 /* CONST_TRUE_RTX means never -- that's the default. */
4158 {
4161 }
4164 {
4167 }
4172 }
4180 /* Print a scalar FP/SIMD register name. */
4182 {
4183 output_operand_lossage ("incompatible floating point / vector register operand for '%%%c'", code);
4185 }
4193 /* Print the first FP/SIMD register name in a list. */
4195 {
4196 output_operand_lossage ("incompatible floating point / vector register operand for '%%%c'", code);
4198 }
4203 /* Print a scalar FP/SIMD register name + 1. */
4205 {
4206 output_operand_lossage ("incompatible floating point / vector register operand for '%%%c'", code);
4208 }
4213 /* Print bottom 16 bits of integer constant in hex. */
4215 {
4218 }
4224 /* Print a general register name or the zero register (32-bit or
4225 64-bit). */
4228 {
4231 }
4234 {
4237 }
4240 {
4243 }
4245 /* Fall through */
4248 /* Print a normal operand, if it's a general register, then we
4249 assume DImode. */
4251 {
4254 }
4257 {
4278 {
4281 HOST_WIDE_INT_MIN,
4282 HOST_WIDE_INT_MAX));
4284 }
4286 {
4288 }
4289 else
4294 /* CONST_DOUBLE can represent a double-width integer.
4295 In this case, the mode of x is VOIDmode. */
4299 {
4302 }
4304 {
4305 #define buf_size 20
4307 REAL_VALUE_TYPE r;
4314 #undef buf_size
4315 }
4321 }
4329 {
4356 }
4362 {
4389 }
4396 {
4402 }
4407 {
4409 /* Print nzcv. */
4412 {
4415 }
4420 }
4424 {
4426 /* Print nzcv. */
4429 {
4432 }
4437 }
4443 }
4444 }
4446 void
4448 {
4454 {
4458 else
4467 else
4476 else
4485 else
4492 {
4519 }
4530 }
4533 }
4535 bool
4537 {
4544 /* UNSPEC_TLS entries for a symbol include a LABEL_REF for the
4545 referencing instruction, but they are constant offsets, not
4546 symbols. */
4552 {
4554 {
4560 }
4563 }
4566 }
4568 /* Implement REGNO_REG_CLASS. */
4570 enum reg_class
4572 {
4587 }
4589 static rtx
4591 {
4592 /* Try to split X+CONST into Y=X+(CONST & ~mask), Y+(CONST&mask),
4593 where mask is selected by alignment and size of the offset.
4594 We try to pick as large a range for the offset as possible to
4595 maximize the chance of a CSE. However, for aligned addresses
4596 we limit the range to 4k so that structures with different sized
4597 elements are likely to use the same base. */
4600 {
4602 HOST_WIDE_INT base_offset;
4604 /* Does it look like we'll need a load/store-pair operation? */
4609 /* For offsets aren't a multiple of the access size, the limit is
4610 -256...255. */
4613 else
4622 NULL_RTX);
4625 }
4628 }
4630 /* Try a machine-dependent way of reloading an illegitimate address
4631 operand. If we find one, push the reload and return the new rtx. */
4633 rtx
4635 machine_mode mode,
4638 {
4641 /* Do not allow mem (plus (reg, const)) if vector struct mode. */
4646 {
4653 }
4655 /* We must recognize output that we have already generated ourselves. */
4661 {
4666 }
4668 /* We wish to handle large displacements off a base register by splitting
4669 the addend across an add and the mem insn. This can cut the number of
4670 extra insns needed from 3 to 1. It is only useful for load/store of a
4671 single register with 12 bit offset field. */
4679 {
4683 HOST_WIDE_INT offs;
4684 rtx cst;
4687 /* In ILP32, xmode can be either DImode or SImode. */
4690 /* Reload non-zero BLKmode offsets. This is because we cannot ascertain
4691 BLKmode alignment. */
4697 /* Align misaligned offset by adjusting high part to compensate. */
4699 {
4701 {
4702 /* Align down. */
4705 }
4706 else
4707 {
4708 /* Align up. */
4713 }
4714 }
4716 /* Check for overflow. */
4724 /* Reload high part into base reg, leaving the low part
4725 in the mem instruction.
4726 Note that replacing this gen_rtx_PLUS with plus_constant is
4727 wrong in this case because we rely on the
4728 (plus (plus reg c1) c2) structure being preserved so that
4729 XEXP (*p, 0) in push_reload below uses the correct term. */
4738 }
4741 }
4744 static reg_class_t
4746 reg_class_t rclass,
4747 machine_mode mode,
4749 {
4750 /* Without the TARGET_SIMD instructions we cannot move a Q register
4751 to a Q register directly. We need a scratch. */
4755 {
4761 }
4763 /* A TFmode or TImode memory access should be handled via an FP_REGS
4764 because AArch64 has richer addressing modes for LDR/STR instructions
4765 than LDP/STP instructions. */
4774 }
4776 static bool
4778 {
4779 /* If we need a frame pointer, we must eliminate FRAME_POINTER_REGNUM into
4780 HARD_FRAME_POINTER_REGNUM and not into STACK_POINTER_REGNUM. */
4783 {
4795 }
4796 else
4797 {
4798 /* If we decided that we didn't need a leaf frame pointer but then used
4799 LR in the function, then we'll want a frame pointer after all, so
4800 prevent this elimination to ensure a frame pointer is used. */
4802 && flag_omit_leaf_frame_pointer
4805 }
4808 }
4810 HOST_WIDE_INT
4812 {
4816 {
4823 }
4826 {
4830 }
4833 }
4835 /* Implement RETURN_ADDR_RTX. We do not support moving back to a
4836 previous frame. */
4838 rtx
4840 {
4844 }
4847 static void
4849 {
4851 {
4854 }
4855 else
4856 {
4859 }
4864 }
4866 static void
4868 {
4872 /* Don't need to copy the trailing D-words, we fill those in below. */
4884 /* XXX We should really define a "clear_cache" pattern and use
4885 gen_clear_cache(). */
4890 ptr_mode);
4891 }
4893 static unsigned char
4895 {
4897 {
4904 return
4915 }
4917 }
4919 static reg_class_t
4921 {
4926 {
4932 }
4934 /* If it's an integer immediate that MOVI can't handle, then
4935 FP_REGS is not an option, so we return NO_REGS instead. */
4940 /* Register eliminiation can result in a request for
4941 SP+constant->FP_REGS. We cannot support such operations which
4942 use SP as source and an FP_REG as destination, so reject out
4943 right now. */
4945 {
4948 /* Look through a possible SUBREG introduced by ILP32. */
4954 POINTER_REGS));
4956 }
4959 }
4961 void
4963 {
4965 }
4967 static void
4969 {
4972 else
4973 {
4981 }
4982 }
4984 static void
4986 {
4989 else
4990 {
4998 }
4999 }
5003 {
5009 {
5010 {
5013 },
5014 {
5017 },
5018 {
5021 },
5022 /* We assume that DImode is only generated when not optimizing and
5023 that we don't really need 64-bit address offsets. That would
5024 imply an object file with 8GB of code in a single function! */
5025 {
5028 }
5029 };
5037 /* Need to implement table size reduction, by chaning the code below. */
5047 }
5050 /* Return size in bits of an arithmetic operand which is shifted/scaled and
5051 masked such that it is suitable for a UXTB, UXTH, or UXTW extend
5052 operator. */
5054 int
5056 {
5058 {
5061 {
5065 }
5066 }
5068 }
5070 static bool
5072 const_rtx x ATTRIBUTE_UNUSED)
5073 {
5074 /* We can't use blocks for constants when we're using a per-function
5075 constant pool. */
5077 }
5081 rtx x ATTRIBUTE_UNUSED,
5083 {
5084 /* Force all constant pool entries into the current function section. */
5086 }
5089 /* Costs. */
5091 /* Helper function for rtx cost calculation. Strip a shift expression
5092 from X. Returns the inner operand if successful, or the original
5093 expression on failure. */
5094 static rtx
5096 {
5099 /* We accept both ROTATERT and ROTATE: since the RHS must be a constant
5100 we can convert both to ROR during final output. */
5115 }
5117 /* Helper function for rtx cost calculation. Strip an extend
5118 expression from X. Returns the inner operand if successful, or the
5119 original expression on failure. We deal with a number of possible
5120 canonicalization variations here. */
5121 static rtx
5123 {
5126 /* Zero and sign extraction of a widened value. */
5134 /* It can also be represented (for zero-extend) as an AND with an
5135 immediate. */
5144 /* Now handle extended register, as this may also have an optional
5145 left shift by 1..4. */
5159 }
5161 /* Helper function for rtx cost calculation. Calculate the cost of
5162 a MULT, which may be part of a multiply-accumulate rtx. Return
5163 the calculated cost of the expression, recursing manually in to
5164 operands where needed. */
5166 static int
5168 {
5184 /* Integer multiply/fma. */
5186 {
5187 /* The multiply will be canonicalized as a shift, cost it as such. */
5190 {
5192 {
5194 /* ADD (shifted register). */
5196 else
5197 /* LSL (immediate). */
5199 }
5204 }
5206 /* Integer multiplies or FMAs have zero/sign extending variants. */
5211 {
5216 {
5218 /* MADD/SMADDL/UMADDL. */
5220 else
5221 /* MUL/SMULL/UMULL. */
5223 }
5226 }
5228 /* This is either an integer multiply or an FMA. In both cases
5229 we want to recurse and cost the operands. */
5234 {
5236 /* MADD. */
5238 else
5239 /* MUL. */
5241 }
5244 }
5245 else
5246 {
5248 {
5249 /* Floating-point FMA/FMUL can also support negations of the
5250 operands. */
5257 /* FMADD/FNMADD/FNMSUB/FMSUB. */
5259 else
5260 /* FMUL/FNMUL. */
5262 }
5267 }
5268 }
5270 static int
5272 machine_mode mode,
5273 addr_space_t as ATTRIBUTE_UNUSED,
5275 {
5283 {
5285 {
5286 /* This is a CONST or SYMBOL ref which will be split
5287 in a different way depending on the code model in use.
5288 Cost it through the generic infrastructure. */
5290 /* Divide through by the cost of one instruction to
5291 bring it to the same units as the address costs. */
5293 /* The cost is then the cost of preparing the address,
5294 followed by an immediate (possibly 0) offset. */
5296 }
5297 else
5298 {
5299 /* This is most likely a jump table from a case
5300 statement. */
5302 }
5303 }
5306 {
5318 else
5334 }
5338 {
5339 /* For the sake of calculating the cost of the shifted register
5340 component, we can treat same sized modes in the same way. */
5342 {
5355 /* We can't tell, or this is a 128-bit vector. */
5359 }
5360 }
5363 }
5365 /* Return true if the RTX X in mode MODE is a zero or sign extract
5366 usable in an ADD or SUB (extended register) instruction. */
5367 static bool
5369 {
5370 /* Catch add with a sign extract.
5371 This is add_<optab><mode>_multp2. */
5374 {
5385 op1))
5386 {
5388 }
5389 }
5392 }
5394 static bool
5396 {
5398 {
5410 }
5411 }
5413 /* Calculate the cost of calculating (if_then_else (OP0) (OP1) (OP2)),
5414 storing it in *COST. Result is true if the total cost of the operation
5415 has now been calculated. */
5416 static bool
5418 {
5419 rtx inner;
5420 rtx comparator;
5424 {
5428 }
5429 else
5430 {
5434 }
5437 {
5438 /* Conditional branch. */
5441 else
5442 {
5444 {
5446 {
5447 /* TBZ/TBNZ/CBZ/CBNZ. */
5449 /* TBZ/TBNZ. */
5452 else
5453 /* CBZ/CBNZ. */
5457 }
5458 }
5460 {
5461 /* TBZ/TBNZ. */
5464 }
5465 }
5466 }
5468 {
5469 /* It's a conditional operation based on the status flags,
5470 so it must be some flavor of CSEL. */
5472 /* CSNEG, CSINV, and CSINC are handled for free as part of CSEL. */
5481 }
5483 /* We don't know what this is, cost all operands. */
5485 }
5487 /* Calculate the cost of calculating X, storing it in *COST. Result
5488 is true if the total cost of the operation has now been calculated. */
5489 static bool
5492 {
5498 /* By default, assume that everything has equivalent cost to the
5499 cheapest instruction. Any additional costs are applied as a delta
5500 above this default. */
5503 /* TODO: The cost infrastructure currently does not handle
5504 vector operations. Assume that all vector operations
5505 are equally expensive. */
5507 {
5511 }
5514 {
5516 /* The cost depends entirely on the operands to SET. */
5522 {
5525 {
5537 }
5546 /* Fall through. */
5548 /* const0_rtx is in general free, but we will use an
5549 instruction to set a register to 0. */
5551 {
5552 /* The cost is 1 per register copied. */
5556 }
5557 else
5558 /* Cost is just the cost of the RHS of the set. */
5564 /* Bit-field insertion. Strip any redundant widening of
5565 the RHS to meet the width of the target. */
5576 {
5577 /* MOV immediate is assumed to always be cheap. */
5579 }
5580 else
5581 {
5582 /* BFM. */
5586 }
5591 /* We can't make sense of this, assume default cost. */
5594 }
5598 /* If an instruction can incorporate a constant within the
5599 instruction, the instruction's expression avoids calling
5600 rtx_cost() on the constant. If rtx_cost() is called on a
5601 constant, then it is usually because the constant must be
5602 moved into a register by one or more instructions.
5604 The exception is constant 0, which can be expressed
5605 as XZR/WZR and is therefore free. The exception to this is
5606 if we have (set (reg) (const0_rtx)) in which case we must cost
5607 the move. However, we can catch that when we cost the SET, so
5608 we don't need to consider that here. */
5611 else
5612 {
5613 /* To an approximation, building any other constant is
5614 proportionally expensive to the number of instructions
5615 required to build that constant. This is true whether we
5616 are compiling for SPEED or otherwise. */
5619 }
5624 {
5625 /* mov[df,sf]_aarch64. */
5627 /* FMOV (scalar immediate). */
5630 {
5631 /* This will be a load from memory. */
5634 else
5636 }
5637 else
5638 /* Otherwise this is +0.0. We get this using MOVI d0, #0
5639 or MOV v0.s[0], wzr - neither of which are modeled by the
5640 cost tables. Just use the default cost. */
5641 {
5642 }
5643 }
5649 {
5650 /* For loads we want the base cost of a load, plus an
5651 approximation for the additional cost of the addressing
5652 mode. */
5664 }
5672 {
5675 {
5676 /* CSETM. */
5679 }
5681 /* Cost this as SUB wzr, X. */
5685 }
5688 {
5689 /* Support (neg(fma...)) as a single instruction only if
5690 sign of zeros is unimportant. This matches the decision
5691 making in aarch64.md. */
5693 {
5694 /* FNMADD. */
5697 }
5699 /* FNEG. */
5702 }
5719 {
5722 }
5725 {
5726 /* TODO: A write to the CC flags possibly costs extra, this
5727 needs encoding in the cost tables. */
5729 /* CC_ZESWPmode supports zero extend for free. */
5733 /* ANDS. */
5735 {
5738 }
5741 {
5742 /* ADDS (and CMN alias). */
5745 }
5748 {
5749 /* SUBS. */
5752 }
5755 {
5756 /* CMN. */
5763 }
5765 /* CMP.
5767 Compare can freely swap the order of operands, and
5768 canonicalization puts the more complex operation first.
5769 But the integer MINUS logic expects the shift/extend
5770 operation in op1. */
5773 {
5776 }
5778 }
5781 {
5782 /* FCMP. */
5787 {
5788 /* FCMP supports constant 0.0 for no extra cost. */
5790 }
5792 }
5797 {
5801 cost_minus:
5802 /* Detect valid immediates. */
5808 {
5812 /* SUB(S) (immediate). */
5816 }
5818 /* Look for SUB (extended register). */
5820 {
5828 }
5832 /* Cost this as an FMA-alike operation. */
5836 {
5839 speed);
5842 }
5847 {
5849 /* SUB(S). */
5852 /* FSUB. */
5854 }
5856 }
5859 {
5860 rtx new_op0;
5865 cost_plus:
5868 {
5869 /* CSINC. */
5873 }
5878 {
5882 /* ADD (immediate). */
5885 }
5887 /* Look for ADD (extended register). */
5889 {
5897 }
5899 /* Strip any extend, leave shifts behind as we will
5900 cost them through mult_cost. */
5905 {
5907 speed);
5910 }
5916 {
5918 /* ADD. */
5921 /* FADD. */
5923 }
5925 }
5937 {
5944 }
5945 /* Fall through. */
5948 cost_logic:
5958 {
5959 /* This is a UBFM/SBFM. */
5964 }
5967 {
5968 /* We possibly get the immediate for free, this is not
5969 modelled. */
5972 {
5979 }
5980 else
5981 {
5984 /* Handle ORN, EON, or BIC. */
5990 /* If we had a shift on op0 then this is a logical-shift-
5991 by-register/immediate operation. Otherwise, this is just
5992 a logical operation. */
5994 {
5996 {
5997 /* Shift by immediate. */
6000 else
6002 }
6003 else
6005 }
6007 /* In both cases we want to cost both operands. */
6012 }
6013 }
6017 /* MVN. */
6021 /* The logical instruction could have the shifted register form,
6022 but the cost is the same if the shift is processed as a separate
6023 instruction, so we don't bother with it here. */
6029 /* If a value is written in SI mode, then zero extended to DI
6030 mode, the operation will in general be free as a write to
6031 a 'w' register implicitly zeroes the upper bits of an 'x'
6032 register. However, if this is
6034 (set (reg) (zero_extend (reg)))
6036 we must cost the explicit register move. */
6040 {
6044 /* MOV. */
6046 else
6047 /* Free, the cost is that of the SI mode operation. */
6051 }
6053 {
6054 /* All loads can zero extend to any size for free. */
6057 }
6059 /* UXTB/UXTH. */
6067 {
6068 /* LDRSH. */
6070 {
6077 }
6079 }
6090 {
6091 /* LSL (immediate), UBMF, UBFIZ and friends. These are all
6092 aliases. */
6096 /* We can incorporate zero/sign extend for free. */
6103 }
6104 else
6105 {
6106 /* LSLV. */
6111 }
6121 {
6122 /* ASR (immediate) and friends. */
6128 }
6129 else
6130 {
6132 /* ASR (register) and friends. */
6137 }
6142 {
6143 /* LDR. */
6146 }
6149 {
6150 /* ADRP, followed by ADD. */
6154 }
6157 {
6158 /* ADR. */
6161 }
6164 {
6165 /* One extra load instruction, after accessing the GOT. */
6169 }
6174 /* ADRP/ADD (immediate). */
6181 /* UBFX/SBFX. */
6185 /* We can trust that the immediates used will be correct (there
6186 are no by-register forms), so we need only cost op0. */
6192 /* aarch64_rtx_mult_cost always handles recursion to its
6193 operands. */
6199 {
6209 }
6216 {
6218 /* There is no integer SQRT, so only DIV and UDIV can get
6219 here. */
6221 else
6223 }
6251 /* FMSUB, FNMADD, and FNMSUB are free. */
6258 /* aarch64_fnma4_elt_to_64v2df has the NEG as operand 1,
6259 and the by-element operand as operand 0. */
6263 /* Catch vector-by-element operations. The by-element operand can
6264 either be (vec_duplicate (vec_select (x))) or just
6265 (vec_select (x)), depending on whether we are multiplying by
6266 a vector or a scalar.
6268 Canonicalization is not very good in these cases, FMA4 will put the
6269 by-element operand as operand 0, FNMA4 will have it as operand 1. */
6280 /* If the remaining parameters are not registers,
6281 get the cost to put them into registers. */
6300 /* Strip the rounding part. They will all be implemented
6301 by the fcvt* family of instructions anyway. */
6303 {
6312 }
6322 {
6323 /* FABS and FNEG are analogous. */
6326 }
6327 else
6328 {
6329 /* Integer ABS will either be split to
6330 two arithmetic instructions, or will be an ABS
6331 (scalar), which we don't model. */
6335 }
6341 {
6342 /* FMAXNM/FMINNM/FMAX/FMIN.
6343 TODO: This may not be accurate for all implementations, but
6344 we do not model this in the cost tables. */
6346 }
6350 /* The floating point round to integer frint* instructions. */
6352 {
6357 }
6360 {
6365 }
6370 /* Decompose <su>muldi3_highpart. */
6372 mode == DImode
6373 /* (lshiftrt:TI */
6376 /* (mult:TI */
6378 /* (ANY_EXTEND:TI (reg:DI))
6379 (ANY_EXTEND:TI (reg:DI))) */
6386 /* (const_int 64) */
6389 {
6390 /* UMULH/SMULH. */
6398 }
6400 /* Fall through. */
6403 }
6410 }
6412 /* Wrapper around aarch64_rtx_costs, dumps the partial, or total cost
6413 calculated for X. This cost is stored in *COST. Returns true
6414 if the total cost of X was calculated. */
6415 static bool
6418 {
6422 {
6427 }
6430 }
6432 static int
6435 {
6441 /* Caller save and pointer regs are equivalent to GENERAL_REGS. */
6448 /* Moving between GPR and stack cost is the same as GP2GP. */
6453 /* To/From the stack register, we move via the gprs. */
6459 {
6460 /* 128-bit operations on general registers require 2 instructions. */
6468 /* When AdvSIMD instructions are disabled it is not possible to move
6469 a 128-bit value directly between Q registers. This is handled in
6470 secondary reload. A general register is used as a scratch to move
6471 the upper DI value and the lower DI value is moved directly,
6472 hence the cost is the sum of three moves. */
6477 }
6487 }
6489 static int
6491 reg_class_t rclass ATTRIBUTE_UNUSED,
6493 {
6495 }
6497 /* Return the number of instructions that can be issued per cycle. */
6498 static int
6500 {
6502 }
6504 static int
6506 {
6510 }
6512 /* Vectorizer cost model target hooks. */
6514 /* Implement targetm.vectorize.builtin_vectorization_cost. */
6515 static int
6517 tree vectype,
6519 {
6523 {
6570 }
6571 }
6573 /* Implement targetm.vectorize.add_stmt_cost. */
6574 static unsigned
6578 {
6583 {
6588 /* Statements in an inner loop relative to the loop being
6589 vectorized are weighted more heavily. The value here is
6590 a function (linear for now) of the loop nest level. */
6592 {
6598 }
6602 }
6605 }
6609 /* Parse the architecture extension string. */
6611 static void
6613 {
6614 /* The extension string is parsed left to right. */
6617 /* Flag to say whether we are adding or removing an extension. */
6621 {
6625 str++;
6630 else
6634 {
6638 }
6643 {
6647 }
6649 /* Scan over the extensions table trying to find an exact match. */
6651 {
6653 {
6654 /* Add or remove the extension. */
6657 else
6660 }
6661 }
6664 {
6665 /* Extension not found in list. */
6668 }
6671 };
6674 }
6676 /* Parse the ARCH string. */
6678 static void
6680 {
6692 else
6696 {
6699 }
6701 /* Loop through the list of supported ARCHs to find a match. */
6703 {
6705 {
6713 {
6714 /* ARCH string contains at least one extension. */
6716 }
6719 {
6722 }
6725 }
6726 }
6728 /* ARCH name not found in list. */
6731 }
6733 /* Parse the CPU string. */
6735 static void
6737 {
6749 else
6753 {
6756 }
6758 /* Loop through the list of supported CPUs to find a match. */
6760 {
6762 {
6767 {
6768 /* CPU string contains at least one extension. */
6770 }
6773 }
6774 }
6776 /* CPU name not found in list. */
6779 }
6781 /* Parse the TUNE string. */
6783 static void
6785 {
6790 /* Loop through the list of supported CPUs to find a match. */
6792 {
6794 {
6797 }
6798 }
6800 /* CPU name not found in list. */
6803 }
6806 /* Implement TARGET_OPTION_OVERRIDE. */
6808 static void
6810 {
6811 /* -mcpu=CPU is shorthand for -march=ARCH_FOR_CPU, -mtune=CPU.
6812 If either of -march or -mtune is given, they override their
6813 respective component of -mcpu.
6815 So, first parse AARCH64_CPU_STRING, then the others, be careful
6816 with -march as, if -mcpu is not present on the command line, march
6817 must set a sensible default CPU. */
6819 {
6821 }
6824 {
6826 }
6829 {
6831 }
6833 #ifndef HAVE_AS_MABI_OPTION
6834 /* The compiler may have been configured with 2.23.* binutils, which does
6835 not have support for ILP32. */
6838 #endif
6844 /* This target defaults to strict volatile bitfields. */
6848 /* If the user did not specify a processor, choose the default
6849 one for them. This will be the CPU set during configuration using
6850 --with-cpu, otherwise it is "generic". */
6852 {
6855 }
6868 {
6869 #ifdef TARGET_FIX_ERR_A53_835769_DEFAULT
6871 #else
6873 #endif
6874 }
6876 /* If not opzimizing for size, set the default
6877 alignment to what the target wants */
6879 {
6886 }
6892 }
6894 /* Implement targetm.override_options_after_change. */
6896 static void
6898 {
6903 }
6907 {
6911 }
6913 void
6915 {
6917 }
6919 /* A checking mechanism for the implementation of the various code models. */
6920 static void
6922 {
6924 {
6926 {
6938 }
6939 }
6940 else
6942 }
6944 /* Return true if SYMBOL_REF X binds locally. */
6946 static bool
6948 {
6952 }
6954 /* Return true if SYMBOL_REF X is thread local */
6955 static bool
6957 {
6965 }
6967 /* Classify a TLS symbol into one of the TLS kinds. */
6968 enum aarch64_symbol_type
6970 {
6974 {
6991 }
6992 }
6994 /* Return the method that should be used to access SYMBOL_REF or
6995 LABEL_REF X in context CONTEXT. */
6997 enum aarch64_symbol_type
7000 {
7002 {
7004 {
7018 }
7019 }
7022 {
7030 {
7032 /* When we retreive symbol + offset address, we have to make sure
7033 the offset does not cause overflow of the final address. But
7034 we have no way of knowing the address of symbol at compile time
7035 so we can't accurately say if the distance between the PC and
7036 symbol + offset is outside the addressible range of +/-1M in the
7037 TINY code model. So we rely on images not being greater than
7038 1M and cap the offset at 1M and anything beyond 1M will have to
7039 be loaded using an alternative mechanism. */
7046 /* Same reasoning as the tiny code model, but the offset cap here is
7047 4G. */
7066 }
7067 }
7069 /* By default push everything into the constant pool. */
7071 }
7073 bool
7075 {
7077 }
7079 bool
7081 {
7089 }
7091 /* Return true if X holds either a quarter-precision or
7092 floating-point +0.0 constant. */
7093 static bool
7095 {
7099 /* TODO: We could handle moving 0.0 to a TFmode register,
7100 but first we would like to refactor the movtf_aarch64
7101 to be more amicable to split moves properly and
7102 correctly gate on TARGET_SIMD. For now - reject all
7103 constants which are not to SFmode or DFmode registers. */
7110 }
7112 static bool
7114 {
7115 /* Do not allow vector struct mode constants. We could support
7116 0 and -1 easily, but they need support in aarch64-simd.md. */
7120 /* This could probably go away because
7121 we now decompose CONST_INTs according to expand_mov_immediate. */
7132 }
7134 rtx
7136 {
7142 /* Can return in any reg. */
7145 }
7147 /* On AAPCS systems, this is the "struct __va_list". */
7150 /* Implement TARGET_BUILD_BUILTIN_VA_LIST.
7151 Return the type to use as __builtin_va_list.
7153 AAPCS64 \S 7.1.4 requires that va_list be a typedef for a type defined as:
7155 struct __va_list
7156 {
7157 void *__stack;
7158 void *__gr_top;
7159 void *__vr_top;
7160 int __gr_offs;
7161 int __vr_offs;
7162 }; */
7164 static tree
7166 {
7167 tree va_list_name;
7170 /* Create the type. */
7172 /* Give it the required name. */
7174 TYPE_DECL,
7176 va_list_type);
7181 /* Create the fields. */
7184 ptr_type_node);
7187 ptr_type_node);
7190 ptr_type_node);
7193 integer_type_node);
7196 integer_type_node);
7216 /* Compute its layout. */
7220 }
7222 /* Implement TARGET_EXPAND_BUILTIN_VA_START. */
7223 static void
7225 {
7229 tree t;
7235 gr_save_area_size
7237 vr_save_area_size
7241 {
7246 }
7255 NULL_TREE);
7257 NULL_TREE);
7259 NULL_TREE);
7261 NULL_TREE);
7263 NULL_TREE);
7265 /* Emit code to initialize STACK, which points to the next varargs stack
7266 argument. CUM->AAPCS_STACK_SIZE gives the number of stack words used
7267 by named arguments. STACK is 8-byte aligned. */
7274 /* Emit code to initialize GRTOP, the top of the GR save area.
7275 virtual_incoming_args_rtx should have been 16 byte aligned. */
7280 /* Emit code to initialize VRTOP, the top of the VR save area.
7281 This address is gr_save_area_bytes below GRTOP, rounded
7282 down to the next 16-byte boundary. */
7292 /* Emit code to initialize GROFF, the offset from GRTOP of the
7293 next GPR argument. */
7298 /* Likewise emit code to initialize VROFF, the offset from FTOP
7299 of the next VR argument. */
7303 }
7305 /* Implement TARGET_GIMPLIFY_VA_ARG_EXPR. */
7307 static tree
7310 {
7311 tree addr;
7317 machine_mode mode;
7344 type,
7348 {
7349 /* TYPE passed in fp/simd registers. */
7362 {
7365 }
7368 {
7370 }
7371 }
7372 else
7373 {
7374 /* TYPE passed in general registers. */
7387 {
7389 }
7390 }
7392 /* Get a local temporary for the field value. */
7395 /* Emit code to branch if off >= 0. */
7401 {
7402 /* Emit: offs = (offs + 15) & -16. */
7408 }
7409 else
7412 /* Update ap.__[g|v]r_offs */
7417 /* String up. */
7421 /* [cond2] if (ap.__[g|v]r_offs > 0) */
7426 /* String up: make sure the assignment happens before the use. */
7430 /* Prepare the trees handling the argument that is passed on the stack;
7431 the top level node will store in ON_STACK. */
7434 {
7435 /* if (alignof(type) > 8) (arg = arg + 15) & -16; */
7443 }
7444 else
7446 /* Advance ap.__stack */
7454 /* String up roundup and advance. */
7457 /* String up with arg */
7459 /* Big-endianness related address adjustment. */
7462 {
7466 }
7471 /* Adjustment to OFFSET in the case of BIG_ENDIAN. */
7481 {
7482 /* type ha; // treat as "struct {ftype field[n];}"
7483 ... [computing offs]
7484 for (i = 0; i <nregs; ++i, offs += 16)
7485 ha.field[i] = *((ftype *)(ap.__vr_top + offs));
7486 return ha; */
7490 /* Declare a local variable. */
7494 /* Establish the base type. */
7496 {
7509 /* The half precision and quad precision are not fully supported yet. Enable
7510 the following code after the support is complete. Need to find the correct
7511 type node for __fp16 *. */
7512 #if 0
7517 #endif
7520 {
7524 }
7528 }
7530 /* *(field_ptr_t)&ha = *((field_ptr_t)vr_saved_area */
7538 /* ha.field[i] = *((field_ptr_t)vr_saved_area + i) */
7540 {
7550 }
7554 }
7564 }
7566 /* Implement TARGET_SETUP_INCOMING_VARARGS. */
7568 static void
7572 {
7574 CUMULATIVE_ARGS local_cum;
7577 /* The caller has advanced CUM up to, but not beyond, the last named
7578 argument. Advance a local copy of CUM past the last "real" named
7579 argument, to find out how many registers are left over. */
7583 /* Found out how many registers we need to save. */
7588 {
7593 }
7596 {
7598 {
7601 /* virtual_incoming_args_rtx should have been 16-byte aligned. */
7609 }
7611 {
7612 /* We can't use move_block_from_reg, because it will use
7613 the wrong mode, storing D regs only. */
7617 /* Set OFF to the offset from virtual_incoming_args_rtx of
7618 the first vector register. The VR save area lies below
7619 the GR one, and is aligned to 16 bytes. */
7625 {
7633 }
7634 }
7635 }
7637 /* We don't save the size into *PRETEND_SIZE because we want to avoid
7638 any complication of having crtl->args.pretend_args_size changed. */
7643 }
7645 static void
7647 {
7650 {
7652 {
7655 }
7656 }
7657 }
7659 /* Walk down the type tree of TYPE counting consecutive base elements.
7660 If *MODEP is VOIDmode, then set it to the first valid floating point
7661 type. If a non-floating point type is found, or if a floating point
7662 type that doesn't match a non-VOIDmode *MODEP is found, then return -1,
7663 otherwise return the count in the sub-tree. */
7664 static int
7666 {
7667 machine_mode mode;
7668 HOST_WIDE_INT size;
7671 {
7699 /* Use V2SImode and V4SImode as representatives of all 64-bit
7700 and 128-bit vector types. */
7703 {
7712 }
7717 /* Vector modes are considered to be opaque: two vectors are
7718 equivalent for the purposes of being homogeneous aggregates
7719 if they are the same size. */
7726 {
7730 /* Can't handle incomplete types nor sizes that are not
7731 fixed. */
7738 || !index
7749 /* There must be no padding. */
7754 }
7757 {
7760 tree field;
7762 /* Can't handle incomplete types nor sizes that are not
7763 fixed. */
7769 {
7777 }
7779 /* There must be no padding. */
7784 }
7788 {
7789 /* These aren't very interesting except in a degenerate case. */
7792 tree field;
7794 /* Can't handle incomplete types nor sizes that are not
7795 fixed. */
7801 {
7809 }
7811 /* There must be no padding. */
7816 }
7820 }
7823 }
7825 /* Return TRUE if the type, as described by TYPE and MODE, is a composite
7826 type as described in AAPCS64 \S 4.3. This includes aggregate, union and
7827 array types. The C99 floating-point complex types are also considered
7828 as composite types, according to AAPCS64 \S 7.1.1. The complex integer
7829 types, which are GCC extensions and out of the scope of AAPCS64, are
7830 treated as composite types here as well.
7832 Note that MODE itself is not sufficient in determining whether a type
7833 is such a composite type or not. This is because
7834 stor-layout.c:compute_record_mode may have already changed the MODE
7835 (BLKmode) of a RECORD_TYPE TYPE to some other mode. For example, a
7836 structure with only one field may have its MODE set to the mode of the
7837 field. Also an integer mode whose size matches the size of the
7838 RECORD_TYPE type may be used to substitute the original mode
7839 (i.e. BLKmode) in certain circumstances. In other words, MODE cannot be
7840 solely relied on. */
7842 static bool
7844 machine_mode mode)
7845 {
7855 }
7857 /* Return TRUE if the type, as described by TYPE and MODE, is a short vector
7858 type as described in AAPCS64 \S 4.1.2.
7860 See the comment above aarch64_composite_type_p for the notes on MODE. */
7862 static bool
7864 machine_mode mode)
7865 {
7876 }
7878 /* Return TRUE if an argument, whose type is described by TYPE and MODE,
7879 shall be passed or returned in simd/fp register(s) (providing these
7880 parameter passing registers are available).
7882 Upon successful return, *COUNT returns the number of needed registers,
7883 *BASE_MODE returns the mode of the individual register and when IS_HAF
7884 is not NULL, *IS_HA indicates whether or not the argument is a homogeneous
7885 floating-point aggregate or a homogeneous short-vector aggregate. */
7887 static bool
7889 const_tree type,
7893 {
7901 {
7904 }
7906 {
7910 }
7912 {
7916 {
7919 }
7920 else
7922 }
7923 else
7928 }
7930 /* Implement TARGET_STRUCT_VALUE_RTX. */
7932 static rtx
7935 {
7937 }
7939 /* Implements target hook vector_mode_supported_p. */
7940 static bool
7942 {
7953 }
7955 /* Return appropriate SIMD container
7956 for MODE within a vector of WIDTH bits. */
7957 static machine_mode
7959 {
7962 {
7965 {
7980 }
7981 else
7983 {
7994 }
7995 }
7997 }
7999 /* Return 128-bit container as the preferred SIMD mode for MODE. */
8000 static machine_mode
8002 {
8004 }
8006 /* Return the bitmask of possible vector sizes for the vectorizer
8007 to iterate over. */
8008 static unsigned int
8010 {
8012 }
8014 /* Implement TARGET_MANGLE_TYPE. */
8018 {
8019 /* The AArch64 ABI documents say that "__va_list" has to be
8020 managled as if it is in the "std" namespace. */
8024 /* Mangle AArch64-specific internal types. TYPE_NAME is non-NULL_TREE for
8025 builtin types. */
8029 /* Use the default mangling. */
8031 }
8034 /* Return true if the rtx_insn contains a MEM RTX somewhere
8035 in it. */
8037 static bool
8039 {
8046 }
8048 /* Find the first rtx_insn before insn that will generate an assembly
8049 instruction. */
8053 {
8057 do
8058 {
8060 }
8064 }
8066 static bool
8068 {
8070 /* A number of these may be AArch32 only. */
8075 };
8078 {
8081 }
8084 }
8086 /* Check if there is a register dependency between a load and the insn
8087 for which we hold recog_data. */
8089 static bool
8091 {
8092 rtx load_reg;
8102 {
8108 }
8110 }
8113 /* When working around the Cortex-A53 erratum 835769,
8114 given rtx_insn INSN, return true if it is a 64-bit multiply-accumulate
8115 instruction and has a preceding memory instruction such that a NOP
8116 should be inserted between them. */
8118 bool
8120 {
8123 rtx body;
8136 /* aarch64_prev_real_insn can call recog_memoized on insns other than INSN.
8137 Restore recog state to INSN to avoid state corruption. */
8145 /* If the previous insn is a memory op and there is no dependency between
8146 it and the DImode madd, emit a NOP between them. If body is NULL then we
8147 have a complex memory operation, probably a load/store pair.
8148 Be conservative for now and emit a NOP. */
8155 }
8158 /* Implement FINAL_PRESCAN_INSN. */
8160 void
8162 {
8165 }
8168 /* Return the equivalent letter for size. */
8169 static char
8171 {
8173 {
8179 }
8180 }
8182 /* Return true iff x is a uniform vector of floating-point
8183 constants, and the constant can be represented in
8184 quarter-precision form. Note, as aarch64_float_const_representable
8185 rejects both +0.0 and -0.0, we will also reject +0.0 and -0.0. */
8186 static bool
8188 {
8203 {
8211 }
8214 }
8216 /* Return true for valid and false for invalid. */
8217 bool
8220 {
8221 #define CHECK(STRIDE, ELSIZE, CLASS, TEST, SHIFT, NEG) \
8222 matches = 1; \
8223 for (i = 0; i < idx; i += (STRIDE)) \
8224 if (!(TEST)) \
8225 matches = 0; \
8226 if (matches) \
8227 { \
8228 immtype = (CLASS); \
8229 elsize = (ELSIZE); \
8230 eshift = (SHIFT); \
8231 emvn = (NEG); \
8232 break; \
8233 }
8243 {
8249 {
8254 }
8257 }
8259 /* Splat vector constant out into a byte vector. */
8261 {
8262 /* The vector is provided in gcc endian-neutral fashion. For aarch64_be,
8263 it must be laid out in the vector register in reverse order. */
8269 {
8272 }
8274 {
8277 }
8278 else
8282 {
8285 {
8288 }
8291 }
8292 }
8294 /* Sanity check. */
8297 do
8298 {
8347 }
8354 {
8364 /* Un-invert bytes of recognized vector, if necessary. */
8370 {
8371 /* FIXME: Broken on 32-bit H_W_I hosts. */
8380 }
8381 else
8382 {
8386 /* Construct 'abcdefgh' because the assembler cannot handle
8387 generic constants. */
8392 }
8393 }
8396 #undef CHECK
8397 }
8399 /* Check of immediate shift constants are within range. */
8400 bool
8402 {
8406 else
8408 }
8410 /* Return true if X is a uniform vector where all elements
8411 are either the floating-point constant 0.0 or the
8412 integer constant 0. */
8413 bool
8415 {
8417 }
8419 bool
8421 {
8426 {
8431 }
8434 }
8436 bool
8439 machine_mode mode)
8440 {
8453 }
8455 /* Return a const_int vector of VAL. */
8456 rtx
8458 {
8467 }
8469 /* Check OP is a legal scalar immediate for the MOVI instruction. */
8471 bool
8473 {
8474 machine_mode vmode;
8480 }
8482 /* Construct and return a PARALLEL RTX vector with elements numbering the
8483 lanes of either the high (HIGH == TRUE) or low (HIGH == FALSE) half of
8484 the vector - from the perspective of the architecture. This does not
8485 line up with GCC's perspective on lane numbers, so we end up with
8486 different masks depending on our target endian-ness. The diagram
8487 below may help. We must draw the distinction when building masks
8488 which select one half of the vector. An instruction selecting
8489 architectural low-lanes for a big-endian target, must be described using
8490 a mask selecting GCC high-lanes.
8492 Big-Endian Little-Endian
8494 GCC 0 1 2 3 3 2 1 0
8495 | x | x | x | x | | x | x | x | x |
8496 Architecture 3 2 1 0 3 2 1 0
8498 Low Mask: { 2, 3 } { 0, 1 }
8499 High Mask: { 0, 1 } { 2, 3 }
8500 */
8502 rtx
8504 {
8510 rtx t1;
8515 else
8523 }
8525 /* Check OP for validity as a PARALLEL RTX vector with elements
8526 numbering the lanes of either the high (HIGH == TRUE) or low lanes,
8527 from the perspective of the architecture. See the diagram above
8528 aarch64_simd_vect_par_cnst_half for more details. */
8530 bool
8533 {
8546 {
8553 }
8555 }
8557 /* Bounds-check lanes. Ensure OPERAND lies between LOW (inclusive) and
8558 HIGH (exclusive). */
8559 void
8561 const_tree exp)
8562 {
8563 HOST_WIDE_INT lane;
8568 {
8571 else
8573 }
8574 }
8576 /* Return TRUE if OP is a valid vector addressing mode. */
8577 bool
8579 {
8582 }
8584 /* Emit a register copy from operand to operand, taking care not to
8585 early-clobber source registers in the process.
8587 COUNT is the number of components into which the copy needs to be
8588 decomposed. */
8589 void
8592 {
8602 else
8606 }
8608 /* Compute and return the length of aarch64_simd_mov<mode>, where <mode> is
8609 one of VSTRUCT modes: OI, CI or XI. */
8610 int
8612 {
8613 machine_mode mode;
8618 {
8621 {
8630 }
8631 }
8633 }
8635 /* Compute and return the length of aarch64_simd_reglist<mode>, where <mode> is
8636 one of VSTRUCT modes: OI, CI, EI, or XI. */
8637 int
8639 {
8641 }
8643 /* Implement target hook TARGET_VECTOR_ALIGNMENT. The AAPCS64 sets the maximum
8644 alignment of a vector to 128 bits. */
8645 static HOST_WIDE_INT
8647 {
8650 }
8652 /* Implement target hook TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE. */
8653 static bool
8655 {
8659 /* We guarantee alignment for vectors up to 128-bits. */
8664 /* Vectors whose size is <= BIGGEST_ALIGNMENT are naturally aligned. */
8666 }
8668 /* If VALS is a vector constant that can be loaded into a register
8669 using DUP, generate instructions to do so and return an RTX to
8670 assign to the register. Otherwise return NULL_RTX. */
8671 static rtx
8673 {
8678 rtx x;
8685 {
8689 }
8694 /* We can load this constant by using DUP and a constant in a
8695 single ARM register. This will be cheaper than a vector
8696 load. */
8699 }
8702 /* Generate code to load VALS, which is a PARALLEL containing only
8703 constants (for vec_init) or CONST_VECTOR, efficiently into a
8704 register. Returns an RTX to copy into the register, or NULL_RTX
8705 for a PARALLEL that can not be converted into a CONST_VECTOR. */
8706 static rtx
8708 {
8710 rtx const_dup;
8719 {
8720 /* A CONST_VECTOR must contain only CONST_INTs and
8721 CONST_DOUBLEs, but CONSTANT_P allows more (e.g. SYMBOL_REF).
8722 Only store valid constants in a CONST_VECTOR. */
8724 {
8727 n_const++;
8728 }
8731 }
8732 else
8737 /* Load using MOVI/MVNI. */
8740 /* Loaded using DUP. */
8743 /* Load from constant pool. We can not take advantage of single-cycle
8744 LD1 because we need a PC-relative addressing mode. */
8746 else
8747 /* A PARALLEL containing something not valid inside CONST_VECTOR.
8748 We can not construct an initializer. */
8750 }
8752 void
8754 {
8763 {
8767 else
8772 }
8775 {
8778 {
8781 }
8782 }
8784 /* Splat a single non-constant element if we can. */
8786 {
8790 }
8792 /* Half the fields (or less) are non-constant. Load constant then overwrite
8793 varying fields. Hope that this is more efficient than using the stack. */
8795 {
8798 /* Load constant part of vector. We really don't care what goes into the
8799 parts we will overwrite, but we're more likely to be able to load the
8800 constant efficiently if it has fewer, larger, repeating parts
8801 (see aarch64_simd_valid_immediate). */
8803 {
8809 {
8810 /* Look in the copied vector, as more elements are const. */
8813 {
8816 }
8817 }
8819 }
8822 /* Insert variables. */
8827 {
8833 }
8835 }
8837 /* Construct the vector in memory one field at a time
8838 and load the whole vector. */
8846 }
8848 static unsigned HOST_WIDE_INT
8850 {
8851 return
8854 }
8856 #ifndef TLS_SECTION_ASM_FLAG
8858 #endif
8860 void
8862 tree decl ATTRIBUTE_UNUSED)
8863 {
8866 /* If we have already declared this section, we can use an
8867 abbreviated form to switch back to it -- unless this section is
8868 part of a COMDAT groups, in which case GAS requires the full
8869 declaration every time. */
8872 {
8875 }
8898 {
8904 else
8907 #ifdef TYPE_OPERAND_FMT
8909 #else
8911 #endif
8918 {
8921 else
8924 }
8925 }
8928 }
8930 /* Select a format to encode pointers in exception handling data. */
8931 int
8933 {
8936 {
8941 /* text+got+data < 4Gb. 4-byte signed relocs are sufficient
8942 for everything. */
8946 /* No assumptions here. 8-byte relocs required. */
8949 }
8951 }
8953 /* Emit load exclusive. */
8955 static void
8958 {
8962 {
8969 }
8972 }
8974 /* Emit store exclusive. */
8976 static void
8979 {
8983 {
8990 }
8993 }
8995 /* Mark the previous jump instruction as unlikely. */
8997 static void
8999 {
9004 }
9006 /* Expand a compare and swap pattern. */
9008 void
9010 {
9026 /* Normally the succ memory model must be stronger than fail, but in the
9027 unlikely event of fail being ACQUIRE and succ being RELEASE we need to
9028 promote succ to ACQ_REL so that we don't lose the acquire semantics. */
9035 {
9038 /* For short modes, we're going to perform the comparison in SImode,
9039 so do the zero-extension now. */
9043 /* Fall through. */
9047 /* Force the value into a register if needed. */
9054 }
9057 {
9064 }
9074 }
9076 /* Split a compare and swap pattern. */
9078 void
9080 {
9082 machine_mode mode;
9097 {
9100 }
9114 {
9119 }
9120 else
9121 {
9125 }
9128 }
9130 /* Split an atomic operation. */
9132 void
9135 {
9139 rtx x;
9148 else
9155 {
9169 {
9172 }
9173 /* Fall through. */
9179 }
9188 }
9190 static void
9192 {
9200 }
9202 static void
9204 {
9206 {
9209 }
9211 {
9216 }
9218 }
9220 /* Target hook for c_mode_for_suffix. */
9221 static machine_mode
9223 {
9228 }
9230 /* We can only represent floating point constants which will fit in
9231 "quarter-precision" values. These values are characterised by
9232 a sign bit, a 4-bit mantissa and a 3-bit exponent. And are given
9233 by:
9235 (-1)^s * (n/16) * 2^r
9237 Where:
9238 's' is the sign bit.
9239 'n' is an integer in the range 16 <= n <= 31.
9240 'r' is an integer in the range -3 <= r <= 4. */
9242 /* Return true iff X can be represented by a quarter-precision
9243 floating point immediate operand X. Note, we cannot represent 0.0. */
9244 bool
9246 {
9247 /* This represents our current view of how many bits
9248 make up the mantissa. */
9263 /* We cannot represent infinities, NaNs or +/-zero. We won't
9264 know if we have +zero until we analyse the mantissa, but we
9265 can reject the other invalid values. */
9270 /* Extract exponent. */
9274 /* For the mantissa, we expand into two HOST_WIDE_INTS, apart from the
9275 highest (sign) bit, with a fixed binary point at bit point_pos.
9276 m1 holds the low part of the mantissa, m2 the high part.
9277 WARNING: If we ever have a representation using more than 2 * H_W_I - 1
9278 bits for the mantissa, this can fail (low bits will be lost). */
9282 /* If the low part of the mantissa has bits set we cannot represent
9283 the value. */
9286 /* We have rejected the lower HOST_WIDE_INT, so update our
9287 understanding of how many bits lie in the mantissa and
9288 look only at the high HOST_WIDE_INT. */
9292 /* We can only represent values with a mantissa of the form 1.xxxx. */
9297 /* Having filtered unrepresentable values, we may now remove all
9298 but the highest 5 bits. */
9301 /* We cannot represent the value 0.0, so reject it. This is handled
9302 elsewhere. */
9306 /* Then, as bit 4 is always set, we can mask it off, leaving
9307 the mantissa in the range [0, 15]. */
9311 /* GCC internally does not use IEEE754-like encoding (where normalized
9312 significands are in the range [1, 2). GCC uses [0.5, 1) (see real.c).
9313 Our mantissa values are shifted 4 places to the left relative to
9314 normalized IEEE754 so we must modify the exponent returned by REAL_EXP
9315 by 5 places to correct for GCC's representation. */
9319 }
9323 machine_mode mode,
9325 {
9335 /* This will return true to show const_vector is legal for use as either
9336 a AdvSIMD MOVI instruction (or, implicitly, MVNI) immediate. It will
9337 also update INFO to show how the immediate should be generated. */
9346 {
9350 else
9351 {
9352 #define buf_size 20
9353 REAL_VALUE_TYPE r;
9357 #undef buf_size
9361 else
9365 }
9366 }
9378 else
9382 }
9386 machine_mode mode)
9387 {
9388 machine_mode vmode;
9394 }
9396 /* Split operands into moves from op[1] + op[2] into op[0]. */
9398 void
9400 {
9411 {
9412 /* No-op move. Can't split to nothing; emit something. */
9415 }
9417 /* Preserve register attributes for variable tracking. */
9422 /* Special case of reversed high/low parts. */
9425 {
9429 }
9431 {
9432 /* Try to avoid unnecessary moves if part of the result
9433 is in the right place already. */
9438 }
9439 else
9440 {
9445 }
9446 }
9448 /* vec_perm support. */
9450 #define MAX_VECT_LEN 16
9452 struct expand_vec_perm_d
9453 {
9456 machine_mode vmode;
9460 };
9462 /* Generate a variable permutation. */
9464 static void
9466 {
9477 {
9479 {
9480 /* Expand the argument to a V16QI mode by duplicating it. */
9484 }
9485 else
9486 {
9488 }
9489 }
9490 else
9491 {
9492 rtx pair;
9495 {
9499 }
9500 else
9501 {
9505 }
9506 }
9507 }
9509 void
9511 {
9515 rtx mask;
9517 /* The TBL instruction does not use a modulo index, so we must take care
9518 of that ourselves. */
9523 /* For big-endian, we also need to reverse the index within the vector
9524 (but not which vector). */
9526 {
9527 /* If one_vector_p, mask is a vector of (nelt - 1)'s already. */
9532 }
9534 }
9536 /* Recognize patterns suitable for the TRN instructions. */
9537 static bool
9539 {
9548 /* Note that these are little-endian tests.
9549 We correct for big-endian later. */
9554 else
9559 {
9564 }
9566 /* Success! */
9573 {
9576 }
9580 {
9582 {
9595 }
9596 }
9597 else
9598 {
9600 {
9613 }
9614 }
9618 }
9620 /* Recognize patterns suitable for the UZP instructions. */
9621 static bool
9623 {
9632 /* Note that these are little-endian tests.
9633 We correct for big-endian later. */
9638 else
9643 {
9647 }
9649 /* Success! */
9656 {
9659 }
9663 {
9665 {
9678 }
9679 }
9680 else
9681 {
9683 {
9696 }
9697 }
9701 }
9703 /* Recognize patterns suitable for the ZIP instructions. */
9704 static bool
9706 {
9715 /* Note that these are little-endian tests.
9716 We correct for big-endian later. */
9719 /* Do Nothing. */
9720 ;
9723 else
9728 {
9735 }
9737 /* Success! */
9744 {
9747 }
9751 {
9753 {
9766 }
9767 }
9768 else
9769 {
9771 {
9784 }
9785 }
9789 }
9791 /* Recognize patterns for the EXT insn. */
9793 static bool
9795 {
9798 rtx offset;
9802 /* Check if the extracted indices are increasing by one. */
9804 {
9807 {
9808 /* We'll pass the same vector in twice, so allow indices to wrap. */
9810 }
9813 }
9816 {
9829 }
9831 /* Success! */
9835 /* The case where (location == 0) is a no-op for both big- and little-endian,
9836 and is removed by the mid-end at optimization levels -O1 and higher. */
9839 {
9840 /* After setup, we want the high elements of the first vector (stored
9841 at the LSB end of the register), and the low elements of the second
9842 vector (stored at the MSB end of the register). So swap. */
9844 /* location != 0 (above), so safe to assume (nelt - location) < nelt. */
9846 }
9851 }
9853 /* Recognize patterns for the REV insns. */
9855 static bool
9857 {
9866 {
9869 {
9874 }
9878 {
9885 }
9889 {
9900 }
9904 }
9908 {
9909 /* This is guaranteed to be true as the value of diff
9910 is 7, 3, 1 and we should have enough elements in the
9911 queue to generate this. Getting a vector mask with a
9912 value of diff other than these values implies that
9913 something is wrong by the time we get here. */
9917 }
9919 /* Success! */
9925 }
9927 static bool
9929 {
9932 rtx in0;
9935 rtx lane;
9939 {
9942 }
9944 /* The generic preparation in aarch64_expand_vec_perm_const_1
9945 swaps the operand order and the permute indices if it finds
9946 d->perm[0] to be in the second operand. Thus, we can always
9947 use d->op0 and need not do any extra arithmetic to get the
9948 correct lane number. */
9953 {
9966 }
9970 }
9972 static bool
9974 {
9982 /* Generic code will try constant permutation twice. Once with the
9983 original mode and again with the elements lowered to QImode.
9984 So wait and don't do the selector expansion ourselves. */
9989 {
9992 /* If big-endian and two vectors we end up with a weird mixed-endian
9993 mode on NEON. Reverse the index within each word but not the word
9994 itself. */
9997 }
10003 }
10005 static bool
10007 {
10008 /* The pattern matching functions above are written to look for a small
10009 number to begin the sequence (0, 1, N/2). If we begin with an index
10010 from the second operand, we can swap the operands. */
10012 {
10020 }
10023 {
10037 }
10039 }
10041 /* Expand a vec_perm_const pattern. */
10043 bool
10045 {
10059 {
10064 }
10067 {
10076 /* The elements of PERM do not suggest that only the first operand
10077 is used, but both operands are identical. Allow easier matching
10078 of the permutation by folding the permutation into the single
10079 input vector. */
10080 /* Fall Through. */
10092 }
10095 }
10097 static bool
10100 {
10110 /* Calculate whether all elements are in one vector. */
10112 {
10116 }
10118 /* If all elements are from the second vector, reindex as if from the
10119 first vector. */
10124 /* Check whether the mask can be applied to a single vector. */
10137 }
10139 rtx
10141 {
10142 /* We have to reverse each vector because we dont have
10143 a permuted load that can reverse-load according to ABI rules. */
10144 rtx mask;
10158 }
10160 /* Implement MODES_TIEABLE_P. */
10162 bool
10164 {
10168 /* We specifically want to allow elements of "structure" modes to
10169 be tieable to the structure. This more general condition allows
10170 other rarer situations too. */
10177 }
10179 /* Return a new RTX holding the result of moving POINTER forward by
10180 AMOUNT bytes. */
10182 static rtx
10184 {
10189 }
10191 /* Return a new RTX holding the result of moving POINTER forward by the
10192 size of the mode it points to. */
10194 static rtx
10196 {
10200 }
10202 /* Copy one MODE sized block from SRC to DST, then progress SRC and DST by
10203 MODE bytes. */
10205 static void
10207 machine_mode mode)
10208 {
10211 /* "Cast" the pointers to the correct mode. */
10214 /* Emit the memcpy. */
10217 /* Move the pointers forward. */
10220 }
10222 /* Expand movmem, as if from a __builtin_memcpy. Return true if
10223 we succeed, otherwise return false. */
10225 bool
10227 {
10231 rtx base;
10234 /* When optimizing for size, give a better estimate of the length of a
10235 memcpy call, but use the default otherwise. */
10238 /* We can't do anything smart if the amount to copy is not constant. */
10244 /* Try to keep the number of instructions low. For cases below 16 bytes we
10245 need to make at most two moves. For cases above 16 bytes it will be one
10246 move for each 16 byte chunk, then at most two additional moves. */
10256 /* Simple cases. Copy 0-3 bytes, as (if applicable) a 2-byte, then a
10257 1-byte chunk. */
10259 {
10261 {
10264 }
10270 }
10272 /* Copy 4-8 bytes. First a 4-byte chunk, then (if applicable) a second
10273 4-byte chunk, partially overlapping with the previously copied chunk. */
10275 {
10279 {
10285 }
10287 }
10289 /* Copy more than 8 bytes. Copy chunks of 16 bytes until we run out of
10290 them, then (if applicable) an 8-byte chunk. */
10292 {
10294 {
10297 }
10298 else
10299 {
10302 }
10303 }
10305 /* Finish the final bytes of the copy. We can always do this in one
10306 instruction. We either copy the exact amount we need, or partially
10307 overlap with the previous chunk we copied and copy 8-bytes. */
10316 else
10317 {
10319 {
10323 }
10324 else
10325 {
10331 }
10332 }
10335 }
10337 /* Implement the TARGET_ASAN_SHADOW_OFFSET hook. */
10339 static unsigned HOST_WIDE_INT
10341 {
10343 }
10345 static bool
10350 {
10351 /* STORE_BY_PIECES can be used when copying a constant string, but
10352 in that case each 64-bit chunk takes 5 insns instead of 2 (LDR/STR).
10353 For now we always fail this and let the move_by_pieces code copy
10354 the string from read-only memory. */
10359 }
10361 static enum machine_mode
10363 {
10365 {
10398 }
10399 }
10401 static rtx
10404 {
10423 {
10439 }
10444 {
10447 }
10461 {
10464 }
10469 }
10471 static rtx
10474 {
10493 {
10511 }
10516 {
10519 }
10536 {
10539 }
10545 }
10547 #undef TARGET_GEN_CCMP_FIRST
10548 #define TARGET_GEN_CCMP_FIRST aarch64_gen_ccmp_first
10550 #undef TARGET_GEN_CCMP_NEXT
10551 #define TARGET_GEN_CCMP_NEXT aarch64_gen_ccmp_next
10553 /* Implement TARGET_SCHED_MACRO_FUSION_P. Return true if target supports
10554 instruction fusion of some sort. */
10556 static bool
10558 {
10560 }
10563 /* Implement TARGET_SCHED_MACRO_FUSION_PAIR_P. Return true if PREV and CURR
10564 should be kept together during scheduling. */
10566 static bool
10568 {
10569 rtx set_dest;
10572 /* prev and curr are simple SET insns i.e. no flag setting or branching. */
10580 {
10581 /* We are trying to match:
10582 prev (mov) == (set (reg r0) (const_int imm16))
10583 curr (movk) == (set (zero_extract (reg r0)
10584 (const_int 16)
10585 (const_int 16))
10586 (const_int imm16_1)) */
10598 {
10600 }
10601 }
10605 {
10607 /* We're trying to match:
10608 prev (adrp) == (set (reg r1)
10609 (high (symbol_ref ("SYM"))))
10610 curr (add) == (set (reg r0)
10611 (lo_sum (reg r1)
10612 (symbol_ref ("SYM"))))
10613 Note that r0 need not necessarily be the same as r1, especially
10614 during pre-regalloc scheduling. */
10618 {
10626 }
10627 }
10631 {
10633 /* We're trying to match:
10634 prev (movk) == (set (zero_extract (reg r0)
10635 (const_int 16)
10636 (const_int 32))
10637 (const_int imm16_1))
10638 curr (movk) == (set (zero_extract (reg r0)
10639 (const_int 16)
10640 (const_int 48))
10641 (const_int imm16_2)) */
10657 }
10660 {
10661 /* We're trying to match:
10662 prev (adrp) == (set (reg r0)
10663 (high (symbol_ref ("SYM"))))
10664 curr (ldr) == (set (reg r1)
10665 (mem (lo_sum (reg r0)
10666 (symbol_ref ("SYM")))))
10667 or
10668 curr (ldr) == (set (reg r1)
10669 (zero_extend (mem
10670 (lo_sum (reg r0)
10671 (symbol_ref ("SYM")))))) */
10674 {
10687 }
10688 }
10692 {
10695 /* FIXME: this misses some which is considered simple arthematic
10696 instructions for ThunderX. Simple shifts are missed here. */
10702 }
10705 }
10707 /* If MEM is in the form of [base+offset], extract the two parts
10708 of address and set to BASE and OFFSET, otherwise return false
10709 after clearing BASE and OFFSET. */
10711 bool
10713 {
10714 rtx addr;
10721 {
10725 }
10729 {
10733 }
10739 }
10741 /* Types for scheduling fusion. */
10742 enum sched_fusion_type
10743 {
10745 SCHED_FUSION_LD_SIGN_EXTEND,
10746 SCHED_FUSION_LD_ZERO_EXTEND,
10747 SCHED_FUSION_LD,
10748 SCHED_FUSION_ST,
10749 SCHED_FUSION_NUM
10750 };
10752 /* If INSN is a load or store of address in the form of [base+offset],
10753 extract the two parts and set to BASE and OFFSET. Return scheduling
10754 fusion type this INSN is. */
10756 static enum sched_fusion_type
10758 {
10775 {
10780 }
10782 {
10787 }
10792 {
10795 }
10796 else
10803 }
10805 /* Implement the TARGET_SCHED_FUSION_PRIORITY hook.
10807 Currently we only support to fuse ldr or str instructions, so FUSION_PRI
10808 and PRI are only calculated for these instructions. For other instruction,
10809 FUSION_PRI and PRI are simply set to MAX_PRI - 1. In the future, other
10810 type instruction fusion can be added by returning different priorities.
10812 It's important that irrelevant instructions get the largest FUSION_PRI. */
10814 static void
10817 {
10827 {
10831 }
10833 /* Set FUSION_PRI according to fusion type and base register. */
10836 /* Calculate PRI. */
10839 /* INSN with smaller offset goes first. */
10843 else
10848 }
10850 /* Given OPERANDS of consecutive load/store, check if we can merge
10851 them into ldp/stp. LOAD is true if they are load instructions.
10852 MODE is the mode of memory operands. */
10854 bool
10857 {
10863 {
10871 }
10872 else
10873 {
10878 }
10880 /* The mems cannot be volatile. */
10884 /* Check if the addresses are in the form of [base+offset]. */
10892 /* Check if the bases are same. */
10899 /* Check if the offsets are consecutive. */
10903 /* Check if the addresses are clobbered by load. */
10905 {
10909 /* In increasing order, the last load can clobber the address. */
10912 }
10916 else
10921 else
10924 /* Check if the registers are of same class. */
10929 }
10931 /* Given OPERANDS of consecutive load/store, check if we can merge
10932 them into ldp/stp by adjusting the offset. LOAD is true if they
10933 are load instructions. MODE is the mode of memory operands.
10935 Given below consecutive stores:
10937 str w1, [xb, 0x100]
10938 str w1, [xb, 0x104]
10939 str w1, [xb, 0x108]
10940 str w1, [xb, 0x10c]
10942 Though the offsets are out of the range supported by stp, we can
10943 still pair them after adjusting the offset, like:
10945 add scratch, xb, 0x100
10946 stp w1, w1, [scratch]
10947 stp w1, w1, [scratch, 0x8]
10949 The peephole patterns detecting this opportunity should guarantee
10950 the scratch register is avaliable. */
10952 bool
10955 {
10962 {
10975 }
10976 else
10977 {
10986 }
10987 /* Skip if memory operand is by itslef valid for ldp/stp. */
10991 /* The mems cannot be volatile. */
10996 /* Check if the addresses are in the form of [base+offset]. */
11010 /* Check if the bases are same. */
11021 /* Check if the offsets are consecutive. */
11030 /* Check if the addresses are clobbered by load. */
11032 {
11038 /* In increasing order, the last load can clobber the address. */
11041 }
11045 else
11050 else
11055 else
11060 else
11063 /* Check if the registers are of same class. */
11068 }
11070 /* Given OPERANDS of consecutive load/store, this function pairs them
11071 into ldp/stp after adjusting the offset. It depends on the fact
11072 that addresses of load/store instructions are in increasing order.
11073 MODE is the mode of memory operands. CODE is the rtl operator
11074 which should be applied to all memory operands, it's SIGN_EXTEND,
11075 ZERO_EXTEND or UNKNOWN. */
11077 bool
11080 {
11086 {
11091 }
11092 else
11093 {
11099 }
11104 /* Adjust offset thus it can fit in ldp/stp instruction. */
11112 /* Further adjust to make sure all offsets are OK. */
11114 {
11117 }
11119 /* Make sure the adjustment can be done with ADD/SUB instructions. */
11124 {
11127 }
11129 /* Create new memory references. */
11133 /* Check if the adjusted address is OK for ldp/stp. */
11152 {
11157 }
11159 {
11164 }
11167 {
11172 }
11173 else
11174 {
11179 }
11181 /* Emit adjusting instruction. */
11184 /* Emit ldp/stp instructions. */
11192 }
11194 #undef TARGET_ADDRESS_COST
11195 #define TARGET_ADDRESS_COST aarch64_address_cost
11197 /* This hook will determines whether unnamed bitfields affect the alignment
11198 of the containing structure. The hook returns true if the structure
11199 should inherit the alignment requirements of an unnamed bitfield's
11200 type. */
11201 #undef TARGET_ALIGN_ANON_BITFIELD
11202 #define TARGET_ALIGN_ANON_BITFIELD hook_bool_void_true
11204 #undef TARGET_ASM_ALIGNED_DI_OP
11207 #undef TARGET_ASM_ALIGNED_HI_OP
11210 #undef TARGET_ASM_ALIGNED_SI_OP
11213 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
11214 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK \
11215 hook_bool_const_tree_hwi_hwi_const_tree_true
11217 #undef TARGET_ASM_FILE_START
11218 #define TARGET_ASM_FILE_START aarch64_start_file
11220 #undef TARGET_ASM_OUTPUT_MI_THUNK
11221 #define TARGET_ASM_OUTPUT_MI_THUNK aarch64_output_mi_thunk
11223 #undef TARGET_ASM_SELECT_RTX_SECTION
11224 #define TARGET_ASM_SELECT_RTX_SECTION aarch64_select_rtx_section
11226 #undef TARGET_ASM_TRAMPOLINE_TEMPLATE
11227 #define TARGET_ASM_TRAMPOLINE_TEMPLATE aarch64_asm_trampoline_template
11229 #undef TARGET_BUILD_BUILTIN_VA_LIST
11230 #define TARGET_BUILD_BUILTIN_VA_LIST aarch64_build_builtin_va_list
11232 #undef TARGET_CALLEE_COPIES
11233 #define TARGET_CALLEE_COPIES hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false
11235 #undef TARGET_CAN_ELIMINATE
11236 #define TARGET_CAN_ELIMINATE aarch64_can_eliminate
11238 #undef TARGET_CANNOT_FORCE_CONST_MEM
11239 #define TARGET_CANNOT_FORCE_CONST_MEM aarch64_cannot_force_const_mem
11241 #undef TARGET_CONDITIONAL_REGISTER_USAGE
11242 #define TARGET_CONDITIONAL_REGISTER_USAGE aarch64_conditional_register_usage
11244 /* Only the least significant bit is used for initialization guard
11245 variables. */
11246 #undef TARGET_CXX_GUARD_MASK_BIT
11247 #define TARGET_CXX_GUARD_MASK_BIT hook_bool_void_true
11249 #undef TARGET_C_MODE_FOR_SUFFIX
11250 #define TARGET_C_MODE_FOR_SUFFIX aarch64_c_mode_for_suffix
11252 #ifdef TARGET_BIG_ENDIAN_DEFAULT
11253 #undef TARGET_DEFAULT_TARGET_FLAGS
11254 #define TARGET_DEFAULT_TARGET_FLAGS (MASK_BIG_END)
11255 #endif
11257 #undef TARGET_CLASS_MAX_NREGS
11258 #define TARGET_CLASS_MAX_NREGS aarch64_class_max_nregs
11260 #undef TARGET_BUILTIN_DECL
11261 #define TARGET_BUILTIN_DECL aarch64_builtin_decl
11263 #undef TARGET_EXPAND_BUILTIN
11264 #define TARGET_EXPAND_BUILTIN aarch64_expand_builtin
11266 #undef TARGET_EXPAND_BUILTIN_VA_START
11267 #define TARGET_EXPAND_BUILTIN_VA_START aarch64_expand_builtin_va_start
11269 #undef TARGET_FOLD_BUILTIN
11270 #define TARGET_FOLD_BUILTIN aarch64_fold_builtin
11272 #undef TARGET_FUNCTION_ARG
11273 #define TARGET_FUNCTION_ARG aarch64_function_arg
11275 #undef TARGET_FUNCTION_ARG_ADVANCE
11276 #define TARGET_FUNCTION_ARG_ADVANCE aarch64_function_arg_advance
11278 #undef TARGET_FUNCTION_ARG_BOUNDARY
11279 #define TARGET_FUNCTION_ARG_BOUNDARY aarch64_function_arg_boundary
11281 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
11282 #define TARGET_FUNCTION_OK_FOR_SIBCALL aarch64_function_ok_for_sibcall
11284 #undef TARGET_FUNCTION_VALUE
11285 #define TARGET_FUNCTION_VALUE aarch64_function_value
11287 #undef TARGET_FUNCTION_VALUE_REGNO_P
11288 #define TARGET_FUNCTION_VALUE_REGNO_P aarch64_function_value_regno_p
11290 #undef TARGET_FRAME_POINTER_REQUIRED
11291 #define TARGET_FRAME_POINTER_REQUIRED aarch64_frame_pointer_required
11293 #undef TARGET_GIMPLE_FOLD_BUILTIN
11294 #define TARGET_GIMPLE_FOLD_BUILTIN aarch64_gimple_fold_builtin
11296 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
11297 #define TARGET_GIMPLIFY_VA_ARG_EXPR aarch64_gimplify_va_arg_expr
11299 #undef TARGET_INIT_BUILTINS
11300 #define TARGET_INIT_BUILTINS aarch64_init_builtins
11302 #undef TARGET_LEGITIMATE_ADDRESS_P
11303 #define TARGET_LEGITIMATE_ADDRESS_P aarch64_legitimate_address_hook_p
11305 #undef TARGET_LEGITIMATE_CONSTANT_P
11306 #define TARGET_LEGITIMATE_CONSTANT_P aarch64_legitimate_constant_p
11308 #undef TARGET_LIBGCC_CMP_RETURN_MODE
11309 #define TARGET_LIBGCC_CMP_RETURN_MODE aarch64_libgcc_cmp_return_mode
11311 #undef TARGET_LRA_P
11312 #define TARGET_LRA_P hook_bool_void_true
11314 #undef TARGET_MANGLE_TYPE
11315 #define TARGET_MANGLE_TYPE aarch64_mangle_type
11317 #undef TARGET_MEMORY_MOVE_COST
11318 #define TARGET_MEMORY_MOVE_COST aarch64_memory_move_cost
11320 #undef TARGET_MIN_DIVISIONS_FOR_RECIP_MUL
11321 #define TARGET_MIN_DIVISIONS_FOR_RECIP_MUL aarch64_min_divisions_for_recip_mul
11323 #undef TARGET_MUST_PASS_IN_STACK
11324 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
11326 /* This target hook should return true if accesses to volatile bitfields
11327 should use the narrowest mode possible. It should return false if these
11328 accesses should use the bitfield container type. */
11329 #undef TARGET_NARROW_VOLATILE_BITFIELD
11330 #define TARGET_NARROW_VOLATILE_BITFIELD hook_bool_void_false
11332 #undef TARGET_OPTION_OVERRIDE
11333 #define TARGET_OPTION_OVERRIDE aarch64_override_options
11335 #undef TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE
11336 #define TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE \
11337 aarch64_override_options_after_change
11339 #undef TARGET_PASS_BY_REFERENCE
11340 #define TARGET_PASS_BY_REFERENCE aarch64_pass_by_reference
11342 #undef TARGET_PREFERRED_RELOAD_CLASS
11343 #define TARGET_PREFERRED_RELOAD_CLASS aarch64_preferred_reload_class
11345 #undef TARGET_SCHED_REASSOCIATION_WIDTH
11346 #define TARGET_SCHED_REASSOCIATION_WIDTH aarch64_reassociation_width
11348 #undef TARGET_SECONDARY_RELOAD
11349 #define TARGET_SECONDARY_RELOAD aarch64_secondary_reload
11351 #undef TARGET_SHIFT_TRUNCATION_MASK
11352 #define TARGET_SHIFT_TRUNCATION_MASK aarch64_shift_truncation_mask
11354 #undef TARGET_SETUP_INCOMING_VARARGS
11355 #define TARGET_SETUP_INCOMING_VARARGS aarch64_setup_incoming_varargs
11357 #undef TARGET_STRUCT_VALUE_RTX
11358 #define TARGET_STRUCT_VALUE_RTX aarch64_struct_value_rtx
11360 #undef TARGET_REGISTER_MOVE_COST
11361 #define TARGET_REGISTER_MOVE_COST aarch64_register_move_cost
11363 #undef TARGET_RETURN_IN_MEMORY
11364 #define TARGET_RETURN_IN_MEMORY aarch64_return_in_memory
11366 #undef TARGET_RETURN_IN_MSB
11367 #define TARGET_RETURN_IN_MSB aarch64_return_in_msb
11369 #undef TARGET_RTX_COSTS
11370 #define TARGET_RTX_COSTS aarch64_rtx_costs_wrapper
11372 #undef TARGET_SCHED_ISSUE_RATE
11373 #define TARGET_SCHED_ISSUE_RATE aarch64_sched_issue_rate
11375 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
11376 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD \
11377 aarch64_sched_first_cycle_multipass_dfa_lookahead
11379 #undef TARGET_TRAMPOLINE_INIT
11380 #define TARGET_TRAMPOLINE_INIT aarch64_trampoline_init
11382 #undef TARGET_USE_BLOCKS_FOR_CONSTANT_P
11383 #define TARGET_USE_BLOCKS_FOR_CONSTANT_P aarch64_use_blocks_for_constant_p
11385 #undef TARGET_VECTOR_MODE_SUPPORTED_P
11386 #define TARGET_VECTOR_MODE_SUPPORTED_P aarch64_vector_mode_supported_p
11388 #undef TARGET_ARRAY_MODE_SUPPORTED_P
11389 #define TARGET_ARRAY_MODE_SUPPORTED_P aarch64_array_mode_supported_p
11391 #undef TARGET_VECTORIZE_ADD_STMT_COST
11392 #define TARGET_VECTORIZE_ADD_STMT_COST aarch64_add_stmt_cost
11394 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST
11395 #define TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST \
11396 aarch64_builtin_vectorization_cost
11398 #undef TARGET_VECTORIZE_PREFERRED_SIMD_MODE
11399 #define TARGET_VECTORIZE_PREFERRED_SIMD_MODE aarch64_preferred_simd_mode
11401 #undef TARGET_VECTORIZE_BUILTINS
11402 #define TARGET_VECTORIZE_BUILTINS
11404 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION
11405 #define TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION \
11406 aarch64_builtin_vectorized_function
11408 #undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES
11409 #define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES \
11410 aarch64_autovectorize_vector_sizes
11412 #undef TARGET_ATOMIC_ASSIGN_EXPAND_FENV
11413 #define TARGET_ATOMIC_ASSIGN_EXPAND_FENV \
11414 aarch64_atomic_assign_expand_fenv
11416 /* Section anchor support. */
11418 #undef TARGET_MIN_ANCHOR_OFFSET
11419 #define TARGET_MIN_ANCHOR_OFFSET -256
11421 /* Limit the maximum anchor offset to 4k-1, since that's the limit for a
11422 byte offset; we can do much more for larger data types, but have no way
11423 to determine the size of the access. We assume accesses are aligned. */
11424 #undef TARGET_MAX_ANCHOR_OFFSET
11425 #define TARGET_MAX_ANCHOR_OFFSET 4095
11427 #undef TARGET_VECTOR_ALIGNMENT
11428 #define TARGET_VECTOR_ALIGNMENT aarch64_simd_vector_alignment
11430 #undef TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE
11431 #define TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE \
11432 aarch64_simd_vector_alignment_reachable
11434 /* vec_perm support. */
11436 #undef TARGET_VECTORIZE_VEC_PERM_CONST_OK
11437 #define TARGET_VECTORIZE_VEC_PERM_CONST_OK \
11438 aarch64_vectorize_vec_perm_const_ok
11441 #undef TARGET_FIXED_CONDITION_CODE_REGS
11442 #define TARGET_FIXED_CONDITION_CODE_REGS aarch64_fixed_condition_code_regs
11444 #undef TARGET_FLAGS_REGNUM
11445 #define TARGET_FLAGS_REGNUM CC_REGNUM
11447 #undef TARGET_CALL_FUSAGE_CONTAINS_NON_CALLEE_CLOBBERS
11448 #define TARGET_CALL_FUSAGE_CONTAINS_NON_CALLEE_CLOBBERS true
11450 #undef TARGET_ASAN_SHADOW_OFFSET
11451 #define TARGET_ASAN_SHADOW_OFFSET aarch64_asan_shadow_offset
11453 #undef TARGET_LEGITIMIZE_ADDRESS
11454 #define TARGET_LEGITIMIZE_ADDRESS aarch64_legitimize_address
11456 #undef TARGET_USE_BY_PIECES_INFRASTRUCTURE_P
11457 #define TARGET_USE_BY_PIECES_INFRASTRUCTURE_P \
11458 aarch64_use_by_pieces_infrastructure_p
11460 #undef TARGET_CAN_USE_DOLOOP_P
11461 #define TARGET_CAN_USE_DOLOOP_P can_use_doloop_if_innermost
11463 #undef TARGET_SCHED_MACRO_FUSION_P
11464 #define TARGET_SCHED_MACRO_FUSION_P aarch64_macro_fusion_p
11466 #undef TARGET_SCHED_MACRO_FUSION_PAIR_P
11467 #define TARGET_SCHED_MACRO_FUSION_PAIR_P aarch_macro_fusion_pair_p
11469 #undef TARGET_SCHED_FUSION_PRIORITY
11470 #define TARGET_SCHED_FUSION_PRIORITY aarch64_sched_fusion_priority