LLVM  14.0.0git
PPCISelLowering.h
Go to the documentation of this file.
1 //===-- PPCISelLowering.h - PPC32 DAG Lowering Interface --------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the interfaces that PPC uses to lower LLVM code into a
10 // selection DAG.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_LIB_TARGET_POWERPC_PPCISELLOWERING_H
15 #define LLVM_LIB_TARGET_POWERPC_PPCISELLOWERING_H
16 
17 #include "PPCInstrInfo.h"
25 #include "llvm/IR/Attributes.h"
26 #include "llvm/IR/CallingConv.h"
27 #include "llvm/IR/Function.h"
28 #include "llvm/IR/InlineAsm.h"
29 #include "llvm/IR/Metadata.h"
30 #include "llvm/IR/Type.h"
32 #include <utility>
33 
34 namespace llvm {
35 
36  namespace PPCISD {
37 
38  // When adding a NEW PPCISD node please add it to the correct position in
39  // the enum. The order of elements in this enum matters!
40  // Values that are added after this entry:
41  // STBRX = ISD::FIRST_TARGET_MEMORY_OPCODE
42  // are considered memory opcodes and are treated differently than entries
43  // that come before it. For example, ADD or MUL should be placed before
44  // the ISD::FIRST_TARGET_MEMORY_OPCODE while a LOAD or STORE should come
45  // after it.
46  enum NodeType : unsigned {
47  // Start the numbering where the builtin ops and target ops leave off.
49 
50  /// FSEL - Traditional three-operand fsel node.
51  ///
53 
54  /// XSMAXCDP, XSMINCDP - C-type min/max instructions.
57 
58  /// FCFID - The FCFID instruction, taking an f64 operand and producing
59  /// and f64 value containing the FP representation of the integer that
60  /// was temporarily in the f64 operand.
62 
63  /// Newer FCFID[US] integer-to-floating-point conversion instructions for
64  /// unsigned integers and single-precision outputs.
68 
69  /// FCTI[D,W]Z - The FCTIDZ and FCTIWZ instructions, taking an f32 or f64
70  /// operand, producing an f64 value containing the integer representation
71  /// of that FP value.
74 
75  /// Newer FCTI[D,W]UZ floating-point-to-integer conversion instructions for
76  /// unsigned integers with round toward zero.
79 
80  /// Floating-point-to-interger conversion instructions
83 
84  /// VEXTS, ByteWidth - takes an input in VSFRC and produces an output in
85  /// VSFRC that is sign-extended from ByteWidth to a 64-byte integer.
87 
88  /// Reciprocal estimate instructions (unary FP ops).
89  FRE,
91 
92  /// Test instruction for software square root.
94 
95  /// Square root instruction.
97 
98  /// VPERM - The PPC VPERM Instruction.
99  ///
101 
102  /// XXSPLT - The PPC VSX splat instructions
103  ///
105 
106  /// XXSPLTI_SP_TO_DP - The PPC VSX splat instructions for immediates for
107  /// converting immediate single precision numbers to double precision
108  /// vector or scalar.
110 
111  /// XXSPLTI32DX - The PPC XXSPLTI32DX instruction.
112  ///
114 
115  /// VECINSERT - The PPC vector insert instruction
116  ///
118 
119  /// VECSHL - The PPC vector shift left instruction
120  ///
122 
123  /// XXPERMDI - The PPC XXPERMDI instruction
124  ///
126 
127  /// The CMPB instruction (takes two operands of i32 or i64).
129 
130  /// Hi/Lo - These represent the high and low 16-bit parts of a global
131  /// address respectively. These nodes have two operands, the first of
132  /// which must be a TargetGlobalAddress, and the second of which must be a
133  /// Constant. Selected naively, these turn into 'lis G+C' and 'li G+C',
134  /// though these are usually folded into other nodes.
135  Hi,
136  Lo,
137 
138  /// The following two target-specific nodes are used for calls through
139  /// function pointers in the 64-bit SVR4 ABI.
140 
141  /// OPRC, CHAIN = DYNALLOC(CHAIN, NEGSIZE, FRAME_INDEX)
142  /// This instruction is lowered in PPCRegisterInfo::eliminateFrameIndex to
143  /// compute an allocation on the stack.
145 
146  /// This instruction is lowered in PPCRegisterInfo::eliminateFrameIndex to
147  /// compute an offset from native SP to the address of the most recent
148  /// dynamic alloca.
150 
151  /// To avoid stack clash, allocation is performed by block and each block is
152  /// probed.
154 
155  /// The result of the mflr at function entry, used for PIC code.
157 
158  /// These nodes represent PPC shifts.
159  ///
160  /// For scalar types, only the last `n + 1` bits of the shift amounts
161  /// are used, where n is log2(sizeof(element) * 8). See sld/slw, etc.
162  /// for exact behaviors.
163  ///
164  /// For vector types, only the last n bits are used. See vsld.
168 
169  /// FNMSUB - Negated multiply-subtract instruction.
171 
172  /// EXTSWSLI = The PPC extswsli instruction, which does an extend-sign
173  /// word and shift left immediate.
175 
176  /// The combination of sra[wd]i and addze used to implemented signed
177  /// integer division by a power of 2. The first operand is the dividend,
178  /// and the second is the constant shift amount (representing the
179  /// divisor).
181 
182  /// CALL - A direct function call.
183  /// CALL_NOP is a call with the special NOP which follows 64-bit
184  /// CALL_NOTOC the caller does not use the TOC.
185  /// SVR4 calls and 32-bit/64-bit AIX calls.
189 
190  /// CHAIN,FLAG = MTCTR(VAL, CHAIN[, INFLAG]) - Directly corresponds to a
191  /// MTCTR instruction.
193 
194  /// CHAIN,FLAG = BCTRL(CHAIN, INFLAG) - Directly corresponds to a
195  /// BCTRL instruction.
197 
198  /// CHAIN,FLAG = BCTRL(CHAIN, ADDR, INFLAG) - The combination of a bctrl
199  /// instruction and the TOC reload required on 64-bit ELF, 32-bit AIX
200  /// and 64-bit AIX.
202 
203  /// Return with a flag operand, matched by 'blr'
205 
206  /// R32 = MFOCRF(CRREG, INFLAG) - Represents the MFOCRF instruction.
207  /// This copies the bits corresponding to the specified CRREG into the
208  /// resultant GPR. Bits corresponding to other CR regs are undefined.
210 
211  /// Direct move from a VSX register to a GPR
213 
214  /// Direct move from a GPR to a VSX register (algebraic)
216 
217  /// Direct move from a GPR to a VSX register (zero)
219 
220  /// Direct move of 2 consecutive GPR to a VSX register.
222 
223  /// BUILD_SPE64 and EXTRACT_SPE are analogous to BUILD_PAIR and
224  /// EXTRACT_ELEMENT but take f64 arguments instead of i64, as i64 is
225  /// unsupported for this target.
226  /// Merge 2 GPRs to a single SPE register.
228 
229  /// Extract SPE register component, second argument is high or low.
231 
232  /// Extract a subvector from signed integer vector and convert to FP.
233  /// It is primarily used to convert a (widened) illegal integer vector
234  /// type to a legal floating point vector type.
235  /// For example v2i32 -> widened to v4i32 -> v2f64
237 
238  /// Extract a subvector from unsigned integer vector and convert to FP.
239  /// As with SINT_VEC_TO_FP, used for converting illegal types.
241 
242  /// PowerPC instructions that have SCALAR_TO_VECTOR semantics tend to
243  /// place the value into the least significant element of the most
244  /// significant doubleword in the vector. This is not element zero for
245  /// anything smaller than a doubleword on either endianness. This node has
246  /// the same semantics as SCALAR_TO_VECTOR except that the value remains in
247  /// the aforementioned location in the vector register.
249 
250  // FIXME: Remove these once the ANDI glue bug is fixed:
251  /// i1 = ANDI_rec_1_[EQ|GT]_BIT(i32 or i64 x) - Represents the result of the
252  /// eq or gt bit of CR0 after executing andi. x, 1. This is used to
253  /// implement truncation of i32 or i64 to i1.
256 
257  // READ_TIME_BASE - A read of the 64-bit time-base register on a 32-bit
258  // target (returns (Lo, Hi)). It takes a chain operand.
260 
261  // EH_SJLJ_SETJMP - SjLj exception handling setjmp.
263 
264  // EH_SJLJ_LONGJMP - SjLj exception handling longjmp.
266 
267  /// RESVEC = VCMP(LHS, RHS, OPC) - Represents one of the altivec VCMP*
268  /// instructions. For lack of better number, we use the opcode number
269  /// encoding for the OPC field to identify the compare. For example, 838
270  /// is VCMPGTSH.
272 
273  /// RESVEC, OUTFLAG = VCMP_rec(LHS, RHS, OPC) - Represents one of the
274  /// altivec VCMP*_rec instructions. For lack of better number, we use the
275  /// opcode number encoding for the OPC field to identify the compare. For
276  /// example, 838 is VCMPGTSH.
278 
279  /// CHAIN = COND_BRANCH CHAIN, CRRC, OPC, DESTBB [, INFLAG] - This
280  /// corresponds to the COND_BRANCH pseudo instruction. CRRC is the
281  /// condition register to branch on, OPC is the branch opcode to use (e.g.
282  /// PPC::BLE), DESTBB is the destination block to branch to, and INFLAG is
283  /// an optional input flag argument.
285 
286  /// CHAIN = BDNZ CHAIN, DESTBB - These are used to create counter-based
287  /// loops.
290 
291  /// F8RC = FADDRTZ F8RC, F8RC - This is an FADD done with rounding
292  /// towards zero. Used only as part of the long double-to-int
293  /// conversion sequence.
295 
296  /// F8RC = MFFS - This moves the FPSCR (not modeled) into the register.
298 
299  /// TC_RETURN - A tail call return.
300  /// operand #0 chain
301  /// operand #1 callee (register or absolute)
302  /// operand #2 stack adjustment
303  /// operand #3 optional in flag
305 
306  /// ch, gl = CR6[UN]SET ch, inglue - Toggle CR bit 6 for SVR4 vararg calls
309 
310  /// GPRC = address of _GLOBAL_OFFSET_TABLE_. Used by initial-exec TLS
311  /// for non-position independent code on PPC32.
313 
314  /// GPRC = address of _GLOBAL_OFFSET_TABLE_. Used by general dynamic and
315  /// local dynamic TLS and position indendepent code on PPC32.
317 
318  /// G8RC = ADDIS_GOT_TPREL_HA %x2, Symbol - Used by the initial-exec
319  /// TLS model, produces an ADDIS8 instruction that adds the GOT
320  /// base to sym\@got\@tprel\@ha.
322 
323  /// G8RC = LD_GOT_TPREL_L Symbol, G8RReg - Used by the initial-exec
324  /// TLS model, produces a LD instruction with base register G8RReg
325  /// and offset sym\@got\@tprel\@l. This completes the addition that
326  /// finds the offset of "sym" relative to the thread pointer.
328 
329  /// G8RC = ADD_TLS G8RReg, Symbol - Used by the initial-exec TLS
330  /// model, produces an ADD instruction that adds the contents of
331  /// G8RReg to the thread pointer. Symbol contains a relocation
332  /// sym\@tls which is to be replaced by the thread pointer and
333  /// identifies to the linker that the instruction is part of a
334  /// TLS sequence.
336 
337  /// G8RC = ADDIS_TLSGD_HA %x2, Symbol - For the general-dynamic TLS
338  /// model, produces an ADDIS8 instruction that adds the GOT base
339  /// register to sym\@got\@tlsgd\@ha.
341 
342  /// %x3 = ADDI_TLSGD_L G8RReg, Symbol - For the general-dynamic TLS
343  /// model, produces an ADDI8 instruction that adds G8RReg to
344  /// sym\@got\@tlsgd\@l and stores the result in X3. Hidden by
345  /// ADDIS_TLSGD_L_ADDR until after register assignment.
347 
348  /// %x3 = GET_TLS_ADDR %x3, Symbol - For the general-dynamic TLS
349  /// model, produces a call to __tls_get_addr(sym\@tlsgd). Hidden by
350  /// ADDIS_TLSGD_L_ADDR until after register assignment.
352 
353  /// G8RC = ADDI_TLSGD_L_ADDR G8RReg, Symbol, Symbol - Op that
354  /// combines ADDI_TLSGD_L and GET_TLS_ADDR until expansion following
355  /// register assignment.
357 
358  /// GPRC = TLSGD_AIX, TOC_ENTRY, TOC_ENTRY
359  /// G8RC = TLSGD_AIX, TOC_ENTRY, TOC_ENTRY
360  /// Op that combines two register copies of TOC entries
361  /// (region handle into R3 and variable offset into R4) followed by a
362  /// GET_TLS_ADDR node which will be expanded to a call to __get_tls_addr.
363  /// This node is used in 64-bit mode as well (in which case the result is
364  /// G8RC and inputs are X3/X4).
366 
367  /// G8RC = ADDIS_TLSLD_HA %x2, Symbol - For the local-dynamic TLS
368  /// model, produces an ADDIS8 instruction that adds the GOT base
369  /// register to sym\@got\@tlsld\@ha.
371 
372  /// %x3 = ADDI_TLSLD_L G8RReg, Symbol - For the local-dynamic TLS
373  /// model, produces an ADDI8 instruction that adds G8RReg to
374  /// sym\@got\@tlsld\@l and stores the result in X3. Hidden by
375  /// ADDIS_TLSLD_L_ADDR until after register assignment.
377 
378  /// %x3 = GET_TLSLD_ADDR %x3, Symbol - For the local-dynamic TLS
379  /// model, produces a call to __tls_get_addr(sym\@tlsld). Hidden by
380  /// ADDIS_TLSLD_L_ADDR until after register assignment.
382 
383  /// G8RC = ADDI_TLSLD_L_ADDR G8RReg, Symbol, Symbol - Op that
384  /// combines ADDI_TLSLD_L and GET_TLSLD_ADDR until expansion
385  /// following register assignment.
387 
388  /// G8RC = ADDIS_DTPREL_HA %x3, Symbol - For the local-dynamic TLS
389  /// model, produces an ADDIS8 instruction that adds X3 to
390  /// sym\@dtprel\@ha.
392 
393  /// G8RC = ADDI_DTPREL_L G8RReg, Symbol - For the local-dynamic TLS
394  /// model, produces an ADDI8 instruction that adds G8RReg to
395  /// sym\@got\@dtprel\@l.
397 
398  /// G8RC = PADDI_DTPREL %x3, Symbol - For the pc-rel based local-dynamic TLS
399  /// model, produces a PADDI8 instruction that adds X3 to sym\@dtprel.
401 
402  /// VRRC = VADD_SPLAT Elt, EltSize - Temporary node to be expanded
403  /// during instruction selection to optimize a BUILD_VECTOR into
404  /// operations on splats. This is necessary to avoid losing these
405  /// optimizations due to constant folding.
407 
408  /// CHAIN = SC CHAIN, Imm128 - System call. The 7-bit unsigned
409  /// operand identifies the operating system entry point.
410  SC,
411 
412  /// CHAIN = CLRBHRB CHAIN - Clear branch history rolling buffer.
414 
415  /// GPRC, CHAIN = MFBHRBE CHAIN, Entry, Dummy - Move from branch
416  /// history rolling buffer entry.
418 
419  /// CHAIN = RFEBB CHAIN, State - Return from event-based branch.
421 
422  /// VSRC, CHAIN = XXSWAPD CHAIN, VSRC - Occurs only for little
423  /// endian. Maps to an xxswapd instruction that corrects an lxvd2x
424  /// or stxvd2x instruction. The chain is necessary because the
425  /// sequence replaces a load and needs to provide the same number
426  /// of outputs.
428 
429  /// An SDNode for swaps that are not associated with any loads/stores
430  /// and thereby have no chain.
432 
433  /// An SDNode for Power9 vector absolute value difference.
434  /// operand #0 vector
435  /// operand #1 vector
436  /// operand #2 constant i32 0 or 1, to indicate whether needs to patch
437  /// the most significant bit for signed i32
438  ///
439  /// Power9 VABSD* instructions are designed to support unsigned integer
440  /// vectors (byte/halfword/word), if we want to make use of them for signed
441  /// integer vectors, we have to flip their sign bits first. To flip sign bit
442  /// for byte/halfword integer vector would become inefficient, but for word
443  /// integer vector, we can leverage XVNEGSP to make it efficiently. eg:
444  /// abs(sub(a,b)) => VABSDUW(a+0x80000000, b+0x80000000)
445  /// => VABSDUW((XVNEGSP a), (XVNEGSP b))
447 
448  /// FP_EXTEND_HALF(VECTOR, IDX) - Custom extend upper (IDX=0) half or
449  /// lower (IDX=1) half of v4f32 to v2f64.
451 
452  /// MAT_PCREL_ADDR = Materialize a PC Relative address. This can be done
453  /// either through an add like PADDI or through a PC Relative load like
454  /// PLD.
456 
457  /// TLS_DYNAMIC_MAT_PCREL_ADDR = Materialize a PC Relative address for
458  /// TLS global address when using dynamic access models. This can be done
459  /// through an add like PADDI.
461 
462  /// TLS_LOCAL_EXEC_MAT_ADDR = Materialize an address for TLS global address
463  /// when using local exec access models, and when prefixed instructions are
464  /// available. This is used with ADD_TLS to produce an add like PADDI.
466 
467  /// ACC_BUILD = Build an accumulator register from 4 VSX registers.
469 
470  /// PAIR_BUILD = Build a vector pair register from 2 VSX registers.
472 
473  /// EXTRACT_VSX_REG = Extract one of the underlying vsx registers of
474  /// an accumulator or pair register. This node is needed because
475  /// EXTRACT_SUBVECTOR expects the input and output vectors to have the same
476  /// element type.
478 
479  /// XXMFACC = This corresponds to the xxmfacc instruction.
481 
482  // Constrained conversion from floating point to int
487 
488  /// Constrained integer-to-floating-point conversion instructions.
493 
494  /// Constrained floating point add in round-to-zero mode.
496 
497  /// CHAIN = STBRX CHAIN, GPRC, Ptr, Type - This is a
498  /// byte-swapping store instruction. It byte-swaps the low "Type" bits of
499  /// the GPRC input, then stores it through Ptr. Type can be either i16 or
500  /// i32.
502 
503  /// GPRC, CHAIN = LBRX CHAIN, Ptr, Type - This is a
504  /// byte-swapping load instruction. It loads "Type" bits, byte swaps it,
505  /// then puts it in the bottom bits of the GPRC. TYPE can be either i16
506  /// or i32.
508 
509  /// STFIWX - The STFIWX instruction. The first operand is an input token
510  /// chain, then an f64 value to store, then an address to store it to.
512 
513  /// GPRC, CHAIN = LFIWAX CHAIN, Ptr - This is a floating-point
514  /// load which sign-extends from a 32-bit integer value into the
515  /// destination 64-bit register.
517 
518  /// GPRC, CHAIN = LFIWZX CHAIN, Ptr - This is a floating-point
519  /// load which zero-extends from a 32-bit integer value into the
520  /// destination 64-bit register.
522 
523  /// GPRC, CHAIN = LXSIZX, CHAIN, Ptr, ByteWidth - This is a load of an
524  /// integer smaller than 64 bits into a VSR. The integer is zero-extended.
525  /// This can be used for converting loaded integers to floating point.
527 
528  /// STXSIX - The STXSI[bh]X instruction. The first operand is an input
529  /// chain, then an f64 value to store, then an address to store it to,
530  /// followed by a byte-width for the store.
532 
533  /// VSRC, CHAIN = LXVD2X_LE CHAIN, Ptr - Occurs only for little endian.
534  /// Maps directly to an lxvd2x instruction that will be followed by
535  /// an xxswapd.
537 
538  /// LXVRZX - Load VSX Vector Rightmost and Zero Extend
539  /// This node represents v1i128 BUILD_VECTOR of a zero extending load
540  /// instruction from <byte, halfword, word, or doubleword> to i128.
541  /// Allows utilization of the Load VSX Vector Rightmost Instructions.
543 
544  /// VSRC, CHAIN = LOAD_VEC_BE CHAIN, Ptr - Occurs only for little endian.
545  /// Maps directly to one of lxvd2x/lxvw4x/lxvh8x/lxvb16x depending on
546  /// the vector type to load vector in big-endian element order.
548 
549  /// VSRC, CHAIN = LD_VSX_LH CHAIN, Ptr - This is a floating-point load of a
550  /// v2f32 value into the lower half of a VSR register.
552 
553  /// VSRC, CHAIN = LD_SPLAT, CHAIN, Ptr - a splatting load memory
554  /// instructions such as LXVDSX, LXVWSX.
556 
557  /// CHAIN = STXVD2X CHAIN, VSRC, Ptr - Occurs only for little endian.
558  /// Maps directly to an stxvd2x instruction that will be preceded by
559  /// an xxswapd.
561 
562  /// CHAIN = STORE_VEC_BE CHAIN, VSRC, Ptr - Occurs only for little endian.
563  /// Maps directly to one of stxvd2x/stxvw4x/stxvh8x/stxvb16x depending on
564  /// the vector type to store vector in big-endian element order.
566 
567  /// Store scalar integers from VSR.
569 
570  /// ATOMIC_CMP_SWAP - the exact same as the target-independent nodes
571  /// except they ensure that the compare input is zero-extended for
572  /// sub-word versions because the atomic loads zero-extend.
575 
576  /// GPRC = TOC_ENTRY GA, TOC
577  /// Loads the entry for GA from the TOC, where the TOC base is given by
578  /// the last operand.
580  };
581 
582  } // end namespace PPCISD
583 
584  /// Define some predicates that are used for node matching.
585  namespace PPC {
586 
587  /// isVPKUHUMShuffleMask - Return true if this is the shuffle mask for a
588  /// VPKUHUM instruction.
589  bool isVPKUHUMShuffleMask(ShuffleVectorSDNode *N, unsigned ShuffleKind,
590  SelectionDAG &DAG);
591 
592  /// isVPKUWUMShuffleMask - Return true if this is the shuffle mask for a
593  /// VPKUWUM instruction.
594  bool isVPKUWUMShuffleMask(ShuffleVectorSDNode *N, unsigned ShuffleKind,
595  SelectionDAG &DAG);
596 
597  /// isVPKUDUMShuffleMask - Return true if this is the shuffle mask for a
598  /// VPKUDUM instruction.
599  bool isVPKUDUMShuffleMask(ShuffleVectorSDNode *N, unsigned ShuffleKind,
600  SelectionDAG &DAG);
601 
602  /// isVMRGLShuffleMask - Return true if this is a shuffle mask suitable for
603  /// a VRGL* instruction with the specified unit size (1,2 or 4 bytes).
604  bool isVMRGLShuffleMask(ShuffleVectorSDNode *N, unsigned UnitSize,
605  unsigned ShuffleKind, SelectionDAG &DAG);
606 
607  /// isVMRGHShuffleMask - Return true if this is a shuffle mask suitable for
608  /// a VRGH* instruction with the specified unit size (1,2 or 4 bytes).
609  bool isVMRGHShuffleMask(ShuffleVectorSDNode *N, unsigned UnitSize,
610  unsigned ShuffleKind, SelectionDAG &DAG);
611 
612  /// isVMRGEOShuffleMask - Return true if this is a shuffle mask suitable for
613  /// a VMRGEW or VMRGOW instruction
614  bool isVMRGEOShuffleMask(ShuffleVectorSDNode *N, bool CheckEven,
615  unsigned ShuffleKind, SelectionDAG &DAG);
616  /// isXXSLDWIShuffleMask - Return true if this is a shuffle mask suitable
617  /// for a XXSLDWI instruction.
618  bool isXXSLDWIShuffleMask(ShuffleVectorSDNode *N, unsigned &ShiftElts,
619  bool &Swap, bool IsLE);
620 
621  /// isXXBRHShuffleMask - Return true if this is a shuffle mask suitable
622  /// for a XXBRH instruction.
623  bool isXXBRHShuffleMask(ShuffleVectorSDNode *N);
624 
625  /// isXXBRWShuffleMask - Return true if this is a shuffle mask suitable
626  /// for a XXBRW instruction.
627  bool isXXBRWShuffleMask(ShuffleVectorSDNode *N);
628 
629  /// isXXBRDShuffleMask - Return true if this is a shuffle mask suitable
630  /// for a XXBRD instruction.
631  bool isXXBRDShuffleMask(ShuffleVectorSDNode *N);
632 
633  /// isXXBRQShuffleMask - Return true if this is a shuffle mask suitable
634  /// for a XXBRQ instruction.
635  bool isXXBRQShuffleMask(ShuffleVectorSDNode *N);
636 
637  /// isXXPERMDIShuffleMask - Return true if this is a shuffle mask suitable
638  /// for a XXPERMDI instruction.
639  bool isXXPERMDIShuffleMask(ShuffleVectorSDNode *N, unsigned &ShiftElts,
640  bool &Swap, bool IsLE);
641 
642  /// isVSLDOIShuffleMask - If this is a vsldoi shuffle mask, return the
643  /// shift amount, otherwise return -1.
644  int isVSLDOIShuffleMask(SDNode *N, unsigned ShuffleKind,
645  SelectionDAG &DAG);
646 
647  /// isSplatShuffleMask - Return true if the specified VECTOR_SHUFFLE operand
648  /// specifies a splat of a single element that is suitable for input to
649  /// VSPLTB/VSPLTH/VSPLTW.
650  bool isSplatShuffleMask(ShuffleVectorSDNode *N, unsigned EltSize);
651 
652  /// isXXINSERTWMask - Return true if this VECTOR_SHUFFLE can be handled by
653  /// the XXINSERTW instruction introduced in ISA 3.0. This is essentially any
654  /// shuffle of v4f32/v4i32 vectors that just inserts one element from one
655  /// vector into the other. This function will also set a couple of
656  /// output parameters for how much the source vector needs to be shifted and
657  /// what byte number needs to be specified for the instruction to put the
658  /// element in the desired location of the target vector.
659  bool isXXINSERTWMask(ShuffleVectorSDNode *N, unsigned &ShiftElts,
660  unsigned &InsertAtByte, bool &Swap, bool IsLE);
661 
662  /// getSplatIdxForPPCMnemonics - Return the splat index as a value that is
663  /// appropriate for PPC mnemonics (which have a big endian bias - namely
664  /// elements are counted from the left of the vector register).
665  unsigned getSplatIdxForPPCMnemonics(SDNode *N, unsigned EltSize,
666  SelectionDAG &DAG);
667 
668  /// get_VSPLTI_elt - If this is a build_vector of constants which can be
669  /// formed by using a vspltis[bhw] instruction of the specified element
670  /// size, return the constant being splatted. The ByteSize field indicates
671  /// the number of bytes of each element [124] -> [bhw].
672  SDValue get_VSPLTI_elt(SDNode *N, unsigned ByteSize, SelectionDAG &DAG);
673 
674  // Flags for computing the optimal addressing mode for loads and stores.
675  enum MemOpFlags {
676  MOF_None = 0,
677 
678  // Extension mode for integer loads.
679  MOF_SExt = 1,
680  MOF_ZExt = 1 << 1,
681  MOF_NoExt = 1 << 2,
682 
683  // Address computation flags.
684  MOF_NotAddNorCst = 1 << 5, // Not const. or sum of ptr and scalar.
685  MOF_RPlusSImm16 = 1 << 6, // Reg plus signed 16-bit constant.
686  MOF_RPlusLo = 1 << 7, // Reg plus signed 16-bit relocation
687  MOF_RPlusSImm16Mult4 = 1 << 8, // Reg plus 16-bit signed multiple of 4.
688  MOF_RPlusSImm16Mult16 = 1 << 9, // Reg plus 16-bit signed multiple of 16.
689  MOF_RPlusSImm34 = 1 << 10, // Reg plus 34-bit signed constant.
690  MOF_RPlusR = 1 << 11, // Sum of two variables.
691  MOF_PCRel = 1 << 12, // PC-Relative relocation.
692  MOF_AddrIsSImm32 = 1 << 13, // A simple 32-bit constant.
693 
694  // The in-memory type.
695  MOF_SubWordInt = 1 << 15,
696  MOF_WordInt = 1 << 16,
697  MOF_DoubleWordInt = 1 << 17,
698  MOF_ScalarFloat = 1 << 18, // Scalar single or double precision.
699  MOF_Vector = 1 << 19, // Vector types and quad precision scalars.
700  MOF_Vector256 = 1 << 20,
701 
702  // Subtarget features.
704  MOF_SubtargetP9 = 1 << 23,
705  MOF_SubtargetP10 = 1 << 24,
707  };
708 
709  // The addressing modes for loads and stores.
710  enum AddrMode {
716  };
717  } // end namespace PPC
718 
720  const PPCSubtarget &Subtarget;
721 
722  public:
723  explicit PPCTargetLowering(const PPCTargetMachine &TM,
724  const PPCSubtarget &STI);
725 
726  /// getTargetNodeName() - This method returns the name of a target specific
727  /// DAG node.
728  const char *getTargetNodeName(unsigned Opcode) const override;
729 
730  bool isSelectSupported(SelectSupportKind Kind) const override {
731  // PowerPC does not support scalar condition selects on vectors.
732  return (Kind != SelectSupportKind::ScalarCondVectorVal);
733  }
734 
735  /// getPreferredVectorAction - The code we generate when vector types are
736  /// legalized by promoting the integer element type is often much worse
737  /// than code we generate if we widen the type for applicable vector types.
738  /// The issue with promoting is that the vector is scalaraized, individual
739  /// elements promoted and then the vector is rebuilt. So say we load a pair
740  /// of v4i8's and shuffle them. This will turn into a mess of 8 extending
741  /// loads, moves back into VSR's (or memory ops if we don't have moves) and
742  /// then the VPERM for the shuffle. All in all a very slow sequence.
744  const override {
745  if (!VT.isScalableVector() && VT.getVectorNumElements() != 1 &&
746  VT.getScalarSizeInBits() % 8 == 0)
747  return TypeWidenVector;
749  }
750 
751  bool useSoftFloat() const override;
752 
753  bool hasSPE() const;
754 
755  MVT getScalarShiftAmountTy(const DataLayout &, EVT) const override {
756  return MVT::i32;
757  }
758 
759  bool isCheapToSpeculateCttz() const override {
760  return true;
761  }
762 
763  bool isCheapToSpeculateCtlz() const override {
764  return true;
765  }
766 
767  bool isCtlzFast() const override {
768  return true;
769  }
770 
771  bool isEqualityCmpFoldedWithSignedCmp() const override {
772  return false;
773  }
774 
775  bool hasAndNotCompare(SDValue) const override {
776  return true;
777  }
778 
779  bool preferIncOfAddToSubOfNot(EVT VT) const override;
780 
781  bool convertSetCCLogicToBitwiseLogic(EVT VT) const override {
782  return VT.isScalarInteger();
783  }
784 
785  SDValue getNegatedExpression(SDValue Op, SelectionDAG &DAG, bool LegalOps,
786  bool OptForSize, NegatibleCost &Cost,
787  unsigned Depth = 0) const override;
788 
789  /// getSetCCResultType - Return the ISD::SETCC ValueType
791  EVT VT) const override;
792 
793  /// Return true if target always benefits from combining into FMA for a
794  /// given value type. This must typically return false on targets where FMA
795  /// takes more cycles to execute than FADD.
796  bool enableAggressiveFMAFusion(EVT VT) const override;
797 
798  /// getPreIndexedAddressParts - returns true by value, base pointer and
799  /// offset pointer and addressing mode by reference if the node's address
800  /// can be legally represented as pre-indexed load / store address.
802  SDValue &Offset,
804  SelectionDAG &DAG) const override;
805 
806  /// SelectAddressEVXRegReg - Given the specified addressed, check to see if
807  /// it can be more efficiently represented as [r+imm].
809  SelectionDAG &DAG) const;
810 
811  /// SelectAddressRegReg - Given the specified addressed, check to see if it
812  /// can be more efficiently represented as [r+imm]. If \p EncodingAlignment
813  /// is non-zero, only accept displacement which is not suitable for [r+imm].
814  /// Returns false if it can be represented by [r+imm], which are preferred.
816  SelectionDAG &DAG,
817  MaybeAlign EncodingAlignment = None) const;
818 
819  /// SelectAddressRegImm - Returns true if the address N can be represented
820  /// by a base register plus a signed 16-bit displacement [r+imm], and if it
821  /// is not better represented as reg+reg. If \p EncodingAlignment is
822  /// non-zero, only accept displacements suitable for instruction encoding
823  /// requirement, i.e. multiples of 4 for DS form.
825  SelectionDAG &DAG,
826  MaybeAlign EncodingAlignment) const;
828  SelectionDAG &DAG) const;
829 
830  /// SelectAddressRegRegOnly - Given the specified addressed, force it to be
831  /// represented as an indexed [r+r] operation.
833  SelectionDAG &DAG) const;
834 
835  /// SelectAddressPCRel - Represent the specified address as pc relative to
836  /// be represented as [pc+imm]
837  bool SelectAddressPCRel(SDValue N, SDValue &Base) const;
838 
840 
841  /// LowerOperation - Provide custom lowering hooks for some operations.
842  ///
843  SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
844 
845  /// ReplaceNodeResults - Replace the results of node with an illegal result
846  /// type with new values built out of custom code.
847  ///
849  SelectionDAG &DAG) const override;
850 
851  SDValue expandVSXLoadForLE(SDNode *N, DAGCombinerInfo &DCI) const;
852  SDValue expandVSXStoreForLE(SDNode *N, DAGCombinerInfo &DCI) const;
853 
854  SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override;
855 
856  SDValue BuildSDIVPow2(SDNode *N, const APInt &Divisor, SelectionDAG &DAG,
857  SmallVectorImpl<SDNode *> &Created) const override;
858 
859  Register getRegisterByName(const char* RegName, LLT VT,
860  const MachineFunction &MF) const override;
861 
863  KnownBits &Known,
864  const APInt &DemandedElts,
865  const SelectionDAG &DAG,
866  unsigned Depth = 0) const override;
867 
868  Align getPrefLoopAlignment(MachineLoop *ML) const override;
869 
870  bool shouldInsertFencesForAtomic(const Instruction *I) const override {
871  return true;
872  }
873 
875  AtomicOrdering Ord) const override;
877  AtomicOrdering Ord) const override;
878 
880  shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const override;
881 
884 
886  AtomicRMWInst *AI, Value *AlignedAddr,
887  Value *Incr, Value *Mask,
888  Value *ShiftAmt,
889  AtomicOrdering Ord) const override;
891  AtomicCmpXchgInst *CI,
892  Value *AlignedAddr, Value *CmpVal,
893  Value *NewVal, Value *Mask,
894  AtomicOrdering Ord) const override;
895 
898  MachineBasicBlock *MBB) const override;
901  unsigned AtomicSize,
902  unsigned BinOpcode,
903  unsigned CmpOpcode = 0,
904  unsigned CmpPred = 0) const;
907  bool is8bit,
908  unsigned Opcode,
909  unsigned CmpOpcode = 0,
910  unsigned CmpPred = 0) const;
911 
913  MachineBasicBlock *MBB) const;
914 
916  MachineBasicBlock *MBB) const;
917 
919  MachineBasicBlock *MBB) const;
920 
921  bool hasInlineStackProbe(MachineFunction &MF) const override;
922 
923  unsigned getStackProbeSize(MachineFunction &MF) const;
924 
925  ConstraintType getConstraintType(StringRef Constraint) const override;
926 
927  /// Examine constraint string and operand type and determine a weight value.
928  /// The operand object must already have been set up with the operand type.
930  AsmOperandInfo &info, const char *constraint) const override;
931 
932  std::pair<unsigned, const TargetRegisterClass *>
934  StringRef Constraint, MVT VT) const override;
935 
936  /// getByValTypeAlignment - Return the desired alignment for ByVal aggregate
937  /// function arguments in the caller parameter area. This is the actual
938  /// alignment, not its logarithm.
939  unsigned getByValTypeAlignment(Type *Ty,
940  const DataLayout &DL) const override;
941 
942  /// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
943  /// vector. If it is invalid, don't add anything to Ops.
945  std::string &Constraint,
946  std::vector<SDValue> &Ops,
947  SelectionDAG &DAG) const override;
948 
949  unsigned
950  getInlineAsmMemConstraint(StringRef ConstraintCode) const override {
951  if (ConstraintCode == "es")
953  else if (ConstraintCode == "Q")
955  else if (ConstraintCode == "Z")
957  else if (ConstraintCode == "Zy")
959  return TargetLowering::getInlineAsmMemConstraint(ConstraintCode);
960  }
961 
962  /// isLegalAddressingMode - Return true if the addressing mode represented
963  /// by AM is legal for this target, for a load/store of the specified type.
964  bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM,
965  Type *Ty, unsigned AS,
966  Instruction *I = nullptr) const override;
967 
968  /// isLegalICmpImmediate - Return true if the specified immediate is legal
969  /// icmp immediate, that is the target has icmp instructions which can
970  /// compare a register against the immediate without having to materialize
971  /// the immediate into a register.
972  bool isLegalICmpImmediate(int64_t Imm) const override;
973 
974  /// isLegalAddImmediate - Return true if the specified immediate is legal
975  /// add immediate, that is the target has add instructions which can
976  /// add a register and the immediate without having to materialize
977  /// the immediate into a register.
978  bool isLegalAddImmediate(int64_t Imm) const override;
979 
980  /// isTruncateFree - Return true if it's free to truncate a value of
981  /// type Ty1 to type Ty2. e.g. On PPC it's free to truncate a i64 value in
982  /// register X1 to i32 by referencing its sub-register R1.
983  bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
984  bool isTruncateFree(EVT VT1, EVT VT2) const override;
985 
986  bool isZExtFree(SDValue Val, EVT VT2) const override;
987 
988  bool isFPExtFree(EVT DestVT, EVT SrcVT) const override;
989 
990  /// Returns true if it is beneficial to convert a load of a constant
991  /// to just the constant itself.
993  Type *Ty) const override;
994 
995  bool convertSelectOfConstantsToMath(EVT VT) const override {
996  return true;
997  }
998 
1000  SDValue C) const override;
1001 
1003  EVT VT) const override {
1004  // Only handle float load/store pair because float(fpr) load/store
1005  // instruction has more cycles than integer(gpr) load/store in PPC.
1006  if (Opc != ISD::LOAD && Opc != ISD::STORE)
1007  return false;
1008  if (VT != MVT::f32 && VT != MVT::f64)
1009  return false;
1010 
1011  return true;
1012  }
1013 
1014  // Returns true if the address of the global is stored in TOC entry.
1015  bool isAccessedAsGotIndirect(SDValue N) const;
1016 
1017  bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override;
1018 
1019  bool getTgtMemIntrinsic(IntrinsicInfo &Info,
1020  const CallInst &I,
1021  MachineFunction &MF,
1022  unsigned Intrinsic) const override;
1023 
1024  /// It returns EVT::Other if the type should be determined using generic
1025  /// target-independent logic.
1027  const AttributeList &FuncAttributes) const override;
1028 
1029  /// Is unaligned memory access allowed for the given type, and is it fast
1030  /// relative to software emulation.
1032  EVT VT, unsigned AddrSpace, Align Alignment = Align(1),
1034  bool *Fast = nullptr) const override;
1035 
1036  /// isFMAFasterThanFMulAndFAdd - Return true if an FMA operation is faster
1037  /// than a pair of fmul and fadd instructions. fmuladd intrinsics will be
1038  /// expanded to FMAs when this method returns true, otherwise fmuladd is
1039  /// expanded to fmul + fadd.
1041  EVT VT) const override;
1042 
1043  bool isFMAFasterThanFMulAndFAdd(const Function &F, Type *Ty) const override;
1044 
1045  /// isProfitableToHoist - Check if it is profitable to hoist instruction
1046  /// \p I to its dominator block.
1047  /// For example, it is not profitable if \p I and it's only user can form a
1048  /// FMA instruction, because Powerpc prefers FMADD.
1049  bool isProfitableToHoist(Instruction *I) const override;
1050 
1051  const MCPhysReg *getScratchRegisters(CallingConv::ID CC) const override;
1052 
1053  // Should we expand the build vector with shuffles?
1054  bool
1056  unsigned DefinedValues) const override;
1057 
1058  // Keep the zero-extensions for arguments to libcalls.
1059  bool shouldKeepZExtForFP16Conv() const override { return true; }
1060 
1061  /// createFastISel - This method returns a target-specific FastISel object,
1062  /// or null if the target does not support "fast" instruction selection.
1064  const TargetLibraryInfo *LibInfo) const override;
1065 
1066  /// Returns true if an argument of type Ty needs to be passed in a
1067  /// contiguous block of registers in calling convention CallConv.
1069  Type *Ty, CallingConv::ID CallConv, bool isVarArg,
1070  const DataLayout &DL) const override {
1071  // We support any array type as "consecutive" block in the parameter
1072  // save area. The element type defines the alignment requirement and
1073  // whether the argument should go in GPRs, FPRs, or VRs if available.
1074  //
1075  // Note that clang uses this capability both to implement the ELFv2
1076  // homogeneous float/vector aggregate ABI, and to avoid having to use
1077  // "byval" when passing aggregates that might fully fit in registers.
1078  return Ty->isArrayTy();
1079  }
1080 
1081  /// If a physical register, this returns the register that receives the
1082  /// exception address on entry to an EH pad.
1083  Register
1084  getExceptionPointerRegister(const Constant *PersonalityFn) const override;
1085 
1086  /// If a physical register, this returns the register that receives the
1087  /// exception typeid on entry to a landing pad.
1088  Register
1089  getExceptionSelectorRegister(const Constant *PersonalityFn) const override;
1090 
1091  /// Override to support customized stack guard loading.
1092  bool useLoadStackGuardNode() const override;
1093  void insertSSPDeclarations(Module &M) const override;
1094  Value *getSDagStackGuard(const Module &M) const override;
1095 
1096  bool isFPImmLegal(const APFloat &Imm, EVT VT,
1097  bool ForCodeSize) const override;
1098 
1099  unsigned getJumpTableEncoding() const override;
1100  bool isJumpTableRelative() const override;
1102  SelectionDAG &DAG) const override;
1104  unsigned JTI,
1105  MCContext &Ctx) const override;
1106 
1107  /// SelectOptimalAddrMode - Based on a node N and it's Parent (a MemSDNode),
1108  /// compute the address flags of the node, get the optimal address mode
1109  /// based on the flags, and set the Base and Disp based on the address mode.
1111  SDValue &Disp, SDValue &Base,
1112  SelectionDAG &DAG,
1113  MaybeAlign Align) const;
1114  /// SelectForceXFormMode - Given the specified address, force it to be
1115  /// represented as an indexed [r+r] operation (an XForm instruction).
1117  SelectionDAG &DAG) const;
1118 
1119  /// Structure that collects some common arguments that get passed around
1120  /// between the functions for call lowering.
1121  struct CallFlags {
1123  const bool IsTailCall : 1;
1124  const bool IsVarArg : 1;
1125  const bool IsPatchPoint : 1;
1126  const bool IsIndirect : 1;
1127  const bool HasNest : 1;
1128  const bool NoMerge : 1;
1129 
1131  bool IsPatchPoint, bool IsIndirect, bool HasNest, bool NoMerge)
1135  };
1136 
1137  CCAssignFn *ccAssignFnForCall(CallingConv::ID CC, bool Return,
1138  bool IsVarArg) const;
1139 
1140  private:
1141  struct ReuseLoadInfo {
1142  SDValue Ptr;
1143  SDValue Chain;
1144  SDValue ResChain;
1145  MachinePointerInfo MPI;
1146  bool IsDereferenceable = false;
1147  bool IsInvariant = false;
1148  Align Alignment;
1149  AAMDNodes AAInfo;
1150  const MDNode *Ranges = nullptr;
1151 
1152  ReuseLoadInfo() = default;
1153 
1154  MachineMemOperand::Flags MMOFlags() const {
1156  if (IsDereferenceable)
1158  if (IsInvariant)
1160  return F;
1161  }
1162  };
1163 
1164  // Map that relates a set of common address flags to PPC addressing modes.
1165  std::map<PPC::AddrMode, SmallVector<unsigned, 16>> AddrModesMap;
1166  void initializeAddrModeMap();
1167 
1168  bool canReuseLoadAddress(SDValue Op, EVT MemVT, ReuseLoadInfo &RLI,
1169  SelectionDAG &DAG,
1170  ISD::LoadExtType ET = ISD::NON_EXTLOAD) const;
1171  void spliceIntoChain(SDValue ResChain, SDValue NewResChain,
1172  SelectionDAG &DAG) const;
1173 
1174  void LowerFP_TO_INTForReuse(SDValue Op, ReuseLoadInfo &RLI,
1175  SelectionDAG &DAG, const SDLoc &dl) const;
1176  SDValue LowerFP_TO_INTDirectMove(SDValue Op, SelectionDAG &DAG,
1177  const SDLoc &dl) const;
1178 
1179  bool directMoveIsProfitable(const SDValue &Op) const;
1180  SDValue LowerINT_TO_FPDirectMove(SDValue Op, SelectionDAG &DAG,
1181  const SDLoc &dl) const;
1182 
1183  SDValue LowerINT_TO_FPVector(SDValue Op, SelectionDAG &DAG,
1184  const SDLoc &dl) const;
1185 
1186  SDValue LowerTRUNCATEVector(SDValue Op, SelectionDAG &DAG) const;
1187 
1188  SDValue getFramePointerFrameIndex(SelectionDAG & DAG) const;
1189  SDValue getReturnAddrFrameIndex(SelectionDAG & DAG) const;
1190 
1191  bool
1192  IsEligibleForTailCallOptimization(SDValue Callee,
1193  CallingConv::ID CalleeCC,
1194  bool isVarArg,
1195  const SmallVectorImpl<ISD::InputArg> &Ins,
1196  SelectionDAG& DAG) const;
1197 
1198  bool IsEligibleForTailCallOptimization_64SVR4(
1199  SDValue Callee, CallingConv::ID CalleeCC, const CallBase *CB,
1200  bool isVarArg, const SmallVectorImpl<ISD::OutputArg> &Outs,
1201  const SmallVectorImpl<ISD::InputArg> &Ins, SelectionDAG &DAG) const;
1202 
1203  SDValue EmitTailCallLoadFPAndRetAddr(SelectionDAG &DAG, int SPDiff,
1204  SDValue Chain, SDValue &LROpOut,
1205  SDValue &FPOpOut,
1206  const SDLoc &dl) const;
1207 
1208  SDValue getTOCEntry(SelectionDAG &DAG, const SDLoc &dl, SDValue GA) const;
1209 
1210  SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
1211  SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
1212  SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
1213  SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
1214  SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
1215  SDValue LowerGlobalTLSAddressAIX(SDValue Op, SelectionDAG &DAG) const;
1216  SDValue LowerGlobalTLSAddressLinux(SDValue Op, SelectionDAG &DAG) const;
1217  SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
1218  SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
1219  SDValue LowerSETCC(SDValue Op, SelectionDAG &DAG) const;
1220  SDValue LowerINIT_TRAMPOLINE(SDValue Op, SelectionDAG &DAG) const;
1221  SDValue LowerADJUST_TRAMPOLINE(SDValue Op, SelectionDAG &DAG) const;
1222  SDValue LowerINLINEASM(SDValue Op, SelectionDAG &DAG) const;
1223  SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
1224  SDValue LowerVAARG(SDValue Op, SelectionDAG &DAG) const;
1225  SDValue LowerVACOPY(SDValue Op, SelectionDAG &DAG) const;
1226  SDValue LowerSTACKRESTORE(SDValue Op, SelectionDAG &DAG) const;
1227  SDValue LowerGET_DYNAMIC_AREA_OFFSET(SDValue Op, SelectionDAG &DAG) const;
1228  SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const;
1229  SDValue LowerEH_DWARF_CFA(SDValue Op, SelectionDAG &DAG) const;
1230  SDValue LowerLOAD(SDValue Op, SelectionDAG &DAG) const;
1231  SDValue LowerSTORE(SDValue Op, SelectionDAG &DAG) const;
1232  SDValue LowerTRUNCATE(SDValue Op, SelectionDAG &DAG) const;
1233  SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const;
1234  SDValue LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG,
1235  const SDLoc &dl) const;
1236  SDValue LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
1237  SDValue LowerFLT_ROUNDS_(SDValue Op, SelectionDAG &DAG) const;
1238  SDValue LowerSHL_PARTS(SDValue Op, SelectionDAG &DAG) const;
1239  SDValue LowerSRL_PARTS(SDValue Op, SelectionDAG &DAG) const;
1240  SDValue LowerSRA_PARTS(SDValue Op, SelectionDAG &DAG) const;
1241  SDValue LowerFunnelShift(SDValue Op, SelectionDAG &DAG) const;
1242  SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
1243  SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const;
1244  SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
1245  SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const;
1246  SDValue LowerINTRINSIC_VOID(SDValue Op, SelectionDAG &DAG) const;
1247  SDValue LowerBSWAP(SDValue Op, SelectionDAG &DAG) const;
1248  SDValue LowerATOMIC_CMP_SWAP(SDValue Op, SelectionDAG &DAG) const;
1249  SDValue LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) const;
1250  SDValue LowerMUL(SDValue Op, SelectionDAG &DAG) const;
1251  SDValue LowerFP_EXTEND(SDValue Op, SelectionDAG &DAG) const;
1252  SDValue LowerFP_ROUND(SDValue Op, SelectionDAG &DAG) const;
1253  SDValue LowerROTL(SDValue Op, SelectionDAG &DAG) const;
1254 
1255  SDValue LowerVectorLoad(SDValue Op, SelectionDAG &DAG) const;
1256  SDValue LowerVectorStore(SDValue Op, SelectionDAG &DAG) const;
1257 
1258  SDValue LowerCallResult(SDValue Chain, SDValue InFlag,
1259  CallingConv::ID CallConv, bool isVarArg,
1260  const SmallVectorImpl<ISD::InputArg> &Ins,
1261  const SDLoc &dl, SelectionDAG &DAG,
1262  SmallVectorImpl<SDValue> &InVals) const;
1263 
1264  SDValue FinishCall(CallFlags CFlags, const SDLoc &dl, SelectionDAG &DAG,
1265  SmallVector<std::pair<unsigned, SDValue>, 8> &RegsToPass,
1266  SDValue InFlag, SDValue Chain, SDValue CallSeqStart,
1267  SDValue &Callee, int SPDiff, unsigned NumBytes,
1268  const SmallVectorImpl<ISD::InputArg> &Ins,
1269  SmallVectorImpl<SDValue> &InVals,
1270  const CallBase *CB) const;
1271 
1272  SDValue
1273  LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
1274  const SmallVectorImpl<ISD::InputArg> &Ins,
1275  const SDLoc &dl, SelectionDAG &DAG,
1276  SmallVectorImpl<SDValue> &InVals) const override;
1277 
1278  SDValue LowerCall(TargetLowering::CallLoweringInfo &CLI,
1279  SmallVectorImpl<SDValue> &InVals) const override;
1280 
1281  bool CanLowerReturn(CallingConv::ID CallConv, MachineFunction &MF,
1282  bool isVarArg,
1283  const SmallVectorImpl<ISD::OutputArg> &Outs,
1284  LLVMContext &Context) const override;
1285 
1286  SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
1287  const SmallVectorImpl<ISD::OutputArg> &Outs,
1288  const SmallVectorImpl<SDValue> &OutVals,
1289  const SDLoc &dl, SelectionDAG &DAG) const override;
1290 
1291  SDValue extendArgForPPC64(ISD::ArgFlagsTy Flags, EVT ObjectVT,
1292  SelectionDAG &DAG, SDValue ArgVal,
1293  const SDLoc &dl) const;
1294 
1295  SDValue LowerFormalArguments_AIX(
1296  SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
1297  const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
1298  SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const;
1299  SDValue LowerFormalArguments_64SVR4(
1300  SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
1301  const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
1302  SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const;
1303  SDValue LowerFormalArguments_32SVR4(
1304  SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
1305  const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
1306  SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const;
1307 
1308  SDValue createMemcpyOutsideCallSeq(SDValue Arg, SDValue PtrOff,
1309  SDValue CallSeqStart,
1310  ISD::ArgFlagsTy Flags, SelectionDAG &DAG,
1311  const SDLoc &dl) const;
1312 
1313  SDValue LowerCall_64SVR4(SDValue Chain, SDValue Callee, CallFlags CFlags,
1314  const SmallVectorImpl<ISD::OutputArg> &Outs,
1315  const SmallVectorImpl<SDValue> &OutVals,
1316  const SmallVectorImpl<ISD::InputArg> &Ins,
1317  const SDLoc &dl, SelectionDAG &DAG,
1318  SmallVectorImpl<SDValue> &InVals,
1319  const CallBase *CB) const;
1320  SDValue LowerCall_32SVR4(SDValue Chain, SDValue Callee, CallFlags CFlags,
1321  const SmallVectorImpl<ISD::OutputArg> &Outs,
1322  const SmallVectorImpl<SDValue> &OutVals,
1323  const SmallVectorImpl<ISD::InputArg> &Ins,
1324  const SDLoc &dl, SelectionDAG &DAG,
1325  SmallVectorImpl<SDValue> &InVals,
1326  const CallBase *CB) const;
1327  SDValue LowerCall_AIX(SDValue Chain, SDValue Callee, CallFlags CFlags,
1328  const SmallVectorImpl<ISD::OutputArg> &Outs,
1329  const SmallVectorImpl<SDValue> &OutVals,
1330  const SmallVectorImpl<ISD::InputArg> &Ins,
1331  const SDLoc &dl, SelectionDAG &DAG,
1332  SmallVectorImpl<SDValue> &InVals,
1333  const CallBase *CB) const;
1334 
1335  SDValue lowerEH_SJLJ_SETJMP(SDValue Op, SelectionDAG &DAG) const;
1336  SDValue lowerEH_SJLJ_LONGJMP(SDValue Op, SelectionDAG &DAG) const;
1337  SDValue LowerBITCAST(SDValue Op, SelectionDAG &DAG) const;
1338 
1339  SDValue DAGCombineExtBoolTrunc(SDNode *N, DAGCombinerInfo &DCI) const;
1340  SDValue DAGCombineBuildVector(SDNode *N, DAGCombinerInfo &DCI) const;
1341  SDValue DAGCombineTruncBoolExt(SDNode *N, DAGCombinerInfo &DCI) const;
1342  SDValue combineStoreFPToInt(SDNode *N, DAGCombinerInfo &DCI) const;
1343  SDValue combineFPToIntToFP(SDNode *N, DAGCombinerInfo &DCI) const;
1344  SDValue combineSHL(SDNode *N, DAGCombinerInfo &DCI) const;
1345  SDValue combineSRA(SDNode *N, DAGCombinerInfo &DCI) const;
1346  SDValue combineSRL(SDNode *N, DAGCombinerInfo &DCI) const;
1347  SDValue combineMUL(SDNode *N, DAGCombinerInfo &DCI) const;
1348  SDValue combineADD(SDNode *N, DAGCombinerInfo &DCI) const;
1349  SDValue combineFMALike(SDNode *N, DAGCombinerInfo &DCI) const;
1350  SDValue combineTRUNCATE(SDNode *N, DAGCombinerInfo &DCI) const;
1351  SDValue combineSetCC(SDNode *N, DAGCombinerInfo &DCI) const;
1352  SDValue combineABS(SDNode *N, DAGCombinerInfo &DCI) const;
1353  SDValue combineVSelect(SDNode *N, DAGCombinerInfo &DCI) const;
1354  SDValue combineVectorShuffle(ShuffleVectorSDNode *SVN,
1355  SelectionDAG &DAG) const;
1356  SDValue combineVReverseMemOP(ShuffleVectorSDNode *SVN, LSBaseSDNode *LSBase,
1357  DAGCombinerInfo &DCI) const;
1358 
1359  /// ConvertSETCCToSubtract - looks at SETCC that compares ints. It replaces
1360  /// SETCC with integer subtraction when (1) there is a legal way of doing it
1361  /// (2) keeping the result of comparison in GPR has performance benefit.
1362  SDValue ConvertSETCCToSubtract(SDNode *N, DAGCombinerInfo &DCI) const;
1363 
1364  SDValue getSqrtEstimate(SDValue Operand, SelectionDAG &DAG, int Enabled,
1365  int &RefinementSteps, bool &UseOneConstNR,
1366  bool Reciprocal) const override;
1367  SDValue getRecipEstimate(SDValue Operand, SelectionDAG &DAG, int Enabled,
1368  int &RefinementSteps) const override;
1369  SDValue getSqrtInputTest(SDValue Operand, SelectionDAG &DAG,
1370  const DenormalMode &Mode) const override;
1371  SDValue getSqrtResultForDenormInput(SDValue Operand,
1372  SelectionDAG &DAG) const override;
1373  unsigned combineRepeatedFPDivisors() const override;
1374 
1375  SDValue
1376  combineElementTruncationToVectorTruncation(SDNode *N,
1377  DAGCombinerInfo &DCI) const;
1378 
1379  /// lowerToVINSERTH - Return the SDValue if this VECTOR_SHUFFLE can be
1380  /// handled by the VINSERTH instruction introduced in ISA 3.0. This is
1381  /// essentially any shuffle of v8i16 vectors that just inserts one element
1382  /// from one vector into the other.
1383  SDValue lowerToVINSERTH(ShuffleVectorSDNode *N, SelectionDAG &DAG) const;
1384 
1385  /// lowerToVINSERTB - Return the SDValue if this VECTOR_SHUFFLE can be
1386  /// handled by the VINSERTB instruction introduced in ISA 3.0. This is
1387  /// essentially v16i8 vector version of VINSERTH.
1388  SDValue lowerToVINSERTB(ShuffleVectorSDNode *N, SelectionDAG &DAG) const;
1389 
1390  /// lowerToXXSPLTI32DX - Return the SDValue if this VECTOR_SHUFFLE can be
1391  /// handled by the XXSPLTI32DX instruction introduced in ISA 3.1.
1392  SDValue lowerToXXSPLTI32DX(ShuffleVectorSDNode *N, SelectionDAG &DAG) const;
1393 
1394  // Return whether the call instruction can potentially be optimized to a
1395  // tail call. This will cause the optimizers to attempt to move, or
1396  // duplicate return instructions to help enable tail call optimizations.
1397  bool mayBeEmittedAsTailCall(const CallInst *CI) const override;
1398  bool hasBitPreservingFPLogic(EVT VT) const override;
1399  bool isMaskAndCmp0FoldingBeneficial(const Instruction &AndI) const override;
1400 
1401  /// getAddrModeForFlags - Based on the set of address flags, select the most
1402  /// optimal instruction format to match by.
1403  PPC::AddrMode getAddrModeForFlags(unsigned Flags) const;
1404 
1405  /// computeMOFlags - Given a node N and it's Parent (a MemSDNode), compute
1406  /// the address flags of the load/store instruction that is to be matched.
1407  /// The address flags are stored in a map, which is then searched
1408  /// through to determine the optimal load/store instruction format.
1409  unsigned computeMOFlags(const SDNode *Parent, SDValue N,
1410  SelectionDAG &DAG) const;
1411  }; // end class PPCTargetLowering
1412 
1413  namespace PPC {
1414 
1415  FastISel *createFastISel(FunctionLoweringInfo &FuncInfo,
1416  const TargetLibraryInfo *LibInfo);
1417 
1418  } // end namespace PPC
1419 
1420  bool isIntS16Immediate(SDNode *N, int16_t &Imm);
1421  bool isIntS16Immediate(SDValue Op, int16_t &Imm);
1422  bool isIntS34Immediate(SDNode *N, int64_t &Imm);
1423  bool isIntS34Immediate(SDValue Op, int64_t &Imm);
1424 
1425  bool convertToNonDenormSingle(APInt &ArgAPInt);
1426  bool convertToNonDenormSingle(APFloat &ArgAPFloat);
1427  bool checkConvertToNonDenormSingle(APFloat &ArgAPFloat);
1428 
1429 } // end namespace llvm
1430 
1431 #endif // LLVM_TARGET_POWERPC_PPC32ISELLOWERING_H
llvm::PPCISD::READ_TIME_BASE
@ READ_TIME_BASE
Definition: PPCISelLowering.h:259
llvm::TargetLoweringBase::getPreferredVectorAction
virtual TargetLoweringBase::LegalizeTypeAction getPreferredVectorAction(MVT VT) const
Return the preferred vector type legalization action.
Definition: TargetLowering.h:437
llvm::PPCISD::MTCTR
@ MTCTR
CHAIN,FLAG = MTCTR(VAL, CHAIN[, INFLAG]) - Directly corresponds to a MTCTR instruction.
Definition: PPCISelLowering.h:192
llvm::lltok::APFloat
@ APFloat
Definition: LLToken.h:491
ValueTypes.h
llvm::PPC::isXXINSERTWMask
bool isXXINSERTWMask(ShuffleVectorSDNode *N, unsigned &ShiftElts, unsigned &InsertAtByte, bool &Swap, bool IsLE)
isXXINSERTWMask - Return true if this VECTOR_SHUFFLE can be handled by the XXINSERTW instruction intr...
Definition: PPCISelLowering.cpp:2168
llvm::PPCTargetLowering::getPICJumpTableRelocBase
SDValue getPICJumpTableRelocBase(SDValue Table, SelectionDAG &DAG) const override
Returns relocation base for the given PIC jumptable.
Definition: PPCISelLowering.cpp:3129
llvm::InlineAsm::Constraint_Q
@ Constraint_Q
Definition: InlineAsm.h:251
llvm::ISD::MemIndexedMode
MemIndexedMode
MemIndexedMode enum - This enum defines the load / store indexed addressing modes.
Definition: ISDOpcodes.h:1304
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:102
llvm::PPCTargetLowering::getJumpTableEncoding
unsigned getJumpTableEncoding() const override
Return the entry encoding for a jump table in the current function.
Definition: PPCISelLowering.cpp:3114
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::PPC::isXXSLDWIShuffleMask
bool isXXSLDWIShuffleMask(ShuffleVectorSDNode *N, unsigned &ShiftElts, bool &Swap, bool IsLE)
isXXSLDWIShuffleMask - Return true if this is a shuffle mask suitable for a XXSLDWI instruction.
Definition: PPCISelLowering.cpp:2243
llvm::PPCISD::FCTIDZ
@ FCTIDZ
FCTI[D,W]Z - The FCTIDZ and FCTIWZ instructions, taking an f32 or f64 operand, producing an f64 value...
Definition: PPCISelLowering.h:72
llvm::EVT::isScalarInteger
bool isScalarInteger() const
Return true if this is an integer, but not a vector.
Definition: ValueTypes.h:150
llvm::PPCISD::FSQRT
@ FSQRT
Square root instruction.
Definition: PPCISelLowering.h:96
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:112
llvm::PPCTargetLowering::CallFlags::NoMerge
const bool NoMerge
Definition: PPCISelLowering.h:1128
llvm::PPCISD::BDNZ
@ BDNZ
CHAIN = BDNZ CHAIN, DESTBB - These are used to create counter-based loops.
Definition: PPCISelLowering.h:288
llvm::PPCISD::RFEBB
@ RFEBB
CHAIN = RFEBB CHAIN, State - Return from event-based branch.
Definition: PPCISelLowering.h:420
Metadata.h
llvm::PPC::isXXBRDShuffleMask
bool isXXBRDShuffleMask(ShuffleVectorSDNode *N)
isXXBRDShuffleMask - Return true if this is a shuffle mask suitable for a XXBRD instruction.
Definition: PPCISelLowering.cpp:2326
llvm::TargetLowering::ConstraintType
ConstraintType
Definition: TargetLowering.h:4138
llvm::ISD::NON_EXTLOAD
@ NON_EXTLOAD
Definition: ISDOpcodes.h:1335
llvm::PPCTargetLowering::getPreIndexedAddressParts
bool getPreIndexedAddressParts(SDNode *N, SDValue &Base, SDValue &Offset, ISD::MemIndexedMode &AM, SelectionDAG &DAG) const override
getPreIndexedAddressParts - returns true by value, base pointer and offset pointer and addressing mod...
Definition: PPCISelLowering.cpp:2930
llvm::PPCISD::FP_EXTEND_HALF
@ FP_EXTEND_HALF
FP_EXTEND_HALF(VECTOR, IDX) - Custom extend upper (IDX=0) half or lower (IDX=1) half of v4f32 to v2f6...
Definition: PPCISelLowering.h:450
llvm::PPCISD::VABSD
@ VABSD
An SDNode for Power9 vector absolute value difference.
Definition: PPCISelLowering.h:446
llvm::isIntS34Immediate
bool isIntS34Immediate(SDNode *N, int64_t &Imm)
isIntS34Immediate - This method tests if value of node given can be accurately represented as a sign ...
Definition: PPCISelLowering.cpp:2570
llvm::MCContext
Context object for machine code objects.
Definition: MCContext.h:72
llvm::Function
Definition: Function.h:61
llvm::PPCISD::CLRBHRB
@ CLRBHRB
CHAIN = CLRBHRB CHAIN - Clear branch history rolling buffer.
Definition: PPCISelLowering.h:413
llvm::PPCTargetLowering::shouldKeepZExtForFP16Conv
bool shouldKeepZExtForFP16Conv() const override
Does this target require the clearing of high-order bits in a register passed to the fp16 to fp conve...
Definition: PPCISelLowering.h:1059
llvm::PPC::AM_DForm
@ AM_DForm
Definition: PPCISelLowering.h:712
llvm::PPC::MOF_SubtargetP9
@ MOF_SubtargetP9
Definition: PPCISelLowering.h:704
llvm::PPCTargetLowering::getPreferredVectorAction
TargetLoweringBase::LegalizeTypeAction getPreferredVectorAction(MVT VT) const override
getPreferredVectorAction - The code we generate when vector types are legalized by promoting the inte...
Definition: PPCISelLowering.h:743
llvm::PPCTargetLowering::shouldExpandAtomicRMWInIR
TargetLowering::AtomicExpansionKind shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const override
Returns how the IR-level AtomicExpand pass should expand the given AtomicRMW, if at all.
Definition: PPCISelLowering.cpp:17497
llvm::PPCTargetLowering::SelectAddressRegReg
bool SelectAddressRegReg(SDValue N, SDValue &Base, SDValue &Index, SelectionDAG &DAG, MaybeAlign EncodingAlignment=None) const
SelectAddressRegReg - Given the specified addressed, check to see if it can be more efficiently repre...
Definition: PPCISelLowering.cpp:2587
InlineAsm.h
llvm::PPCTargetLowering::isAccessedAsGotIndirect
bool isAccessedAsGotIndirect(SDValue N) const
Definition: PPCISelLowering.cpp:16027
llvm::PPCISD::MTVSRA
@ MTVSRA
Direct move from a GPR to a VSX register (algebraic)
Definition: PPCISelLowering.h:215
llvm::PPCTargetLowering::isCtlzFast
bool isCtlzFast() const override
Return true if ctlz instruction is fast.
Definition: PPCISelLowering.h:767
llvm::PPC::AM_None
@ AM_None
Definition: PPCISelLowering.h:711
llvm::PPC::MOF_NotAddNorCst
@ MOF_NotAddNorCst
Definition: PPCISelLowering.h:684
llvm::PPCISD::MAT_PCREL_ADDR
@ MAT_PCREL_ADDR
MAT_PCREL_ADDR = Materialize a PC Relative address.
Definition: PPCISelLowering.h:455
llvm::MachineMemOperand::MOInvariant
@ MOInvariant
The memory access always returns the same value (or traps).
Definition: MachineMemOperand.h:145
llvm::PPCISD::ACC_BUILD
@ ACC_BUILD
ACC_BUILD = Build an accumulator register from 4 VSX registers.
Definition: PPCISelLowering.h:468
llvm::PPCTargetLowering::expandVSXLoadForLE
SDValue expandVSXLoadForLE(SDNode *N, DAGCombinerInfo &DCI) const
Definition: PPCISelLowering.cpp:14203
llvm::PPCISD::VPERM
@ VPERM
VPERM - The PPC VPERM Instruction.
Definition: PPCISelLowering.h:100
llvm::SDNode
Represents one node in the SelectionDAG.
Definition: SelectionDAGNodes.h:455
llvm::PPCTargetLowering::getOptimalMemOpType
EVT getOptimalMemOpType(const MemOp &Op, const AttributeList &FuncAttributes) const override
It returns EVT::Other if the type should be determined using generic target-independent logic.
Definition: PPCISelLowering.cpp:16169
llvm::PPC::MOF_RPlusSImm16Mult16
@ MOF_RPlusSImm16Mult16
Definition: PPCISelLowering.h:688
llvm::PPCISD::STXSIX
@ STXSIX
STXSIX - The STXSI[bh]X instruction.
Definition: PPCISelLowering.h:531
llvm::PPCISD::XSMINCDP
@ XSMINCDP
Definition: PPCISelLowering.h:56
llvm::PPCTargetLowering::getTgtMemIntrinsic
bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I, MachineFunction &MF, unsigned Intrinsic) const override
Given an intrinsic, checks if on the target the intrinsic will need to map to a MemIntrinsicNode (tou...
Definition: PPCISelLowering.cpp:16059
llvm::MemOp
Definition: TargetLowering.h:111
llvm::PPCTargetLowering::getSingleConstraintMatchWeight
ConstraintWeight getSingleConstraintMatchWeight(AsmOperandInfo &info, const char *constraint) const override
Examine constraint string and operand type and determine a weight value.
Definition: PPCISelLowering.cpp:15638
llvm::PPC::isSplatShuffleMask
bool isSplatShuffleMask(ShuffleVectorSDNode *N, unsigned EltSize)
isSplatShuffleMask - Return true if the specified VECTOR_SHUFFLE operand specifies a splat of a singl...
Definition: PPCISelLowering.cpp:2100
llvm::PPCISD::BUILD_SPE64
@ BUILD_SPE64
BUILD_SPE64 and EXTRACT_SPE are analogous to BUILD_PAIR and EXTRACT_ELEMENT but take f64 arguments in...
Definition: PPCISelLowering.h:227
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:231
llvm::Depth
@ Depth
Definition: SIMachineScheduler.h:34
llvm::AAMDNodes
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:651
llvm::PPC::isXXPERMDIShuffleMask
bool isXXPERMDIShuffleMask(ShuffleVectorSDNode *N, unsigned &ShiftElts, bool &Swap, bool IsLE)
isXXPERMDIShuffleMask - Return true if this is a shuffle mask suitable for a XXPERMDI instruction.
Definition: PPCISelLowering.cpp:2342
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::PPCISD::FADDRTZ
@ FADDRTZ
F8RC = FADDRTZ F8RC, F8RC - This is an FADD done with rounding towards zero.
Definition: PPCISelLowering.h:294
llvm::PPCISD::Lo
@ Lo
Definition: PPCISelLowering.h:136
llvm::PPCTargetLowering::ccAssignFnForCall
CCAssignFn * ccAssignFnForCall(CallingConv::ID CC, bool Return, bool IsVarArg) const
Definition: PPCISelLowering.cpp:17485
llvm::AttributeList
Definition: Attributes.h:398
llvm::PPCISD::XXSPLT
@ XXSPLT
XXSPLT - The PPC VSX splat instructions.
Definition: PPCISelLowering.h:104
llvm::PPCISD::LD_GOT_TPREL_L
@ LD_GOT_TPREL_L
G8RC = LD_GOT_TPREL_L Symbol, G8RReg - Used by the initial-exec TLS model, produces a LD instruction ...
Definition: PPCISelLowering.h:327
llvm::PPCISD::FCFIDU
@ FCFIDU
Newer FCFID[US] integer-to-floating-point conversion instructions for unsigned integers and single-pr...
Definition: PPCISelLowering.h:65
llvm::MachineMemOperand::MODereferenceable
@ MODereferenceable
The memory access is dereferenceable (i.e., doesn't trap).
Definition: MachineMemOperand.h:143
llvm::PPCISD::STRICT_FCTIDZ
@ STRICT_FCTIDZ
Definition: PPCISelLowering.h:483
llvm::PPCISD::FNMSUB
@ FNMSUB
FNMSUB - Negated multiply-subtract instruction.
Definition: PPCISelLowering.h:170
llvm::PPCTargetLowering::computeKnownBitsForTargetNode
void computeKnownBitsForTargetNode(const SDValue Op, KnownBits &Known, const APInt &DemandedElts, const SelectionDAG &DAG, unsigned Depth=0) const override
Determine which of the bits specified in Mask are known to be either zero or one and return them in t...
Definition: PPCISelLowering.cpp:15510
llvm::PPCISD::XXSPLTI32DX
@ XXSPLTI32DX
XXSPLTI32DX - The PPC XXSPLTI32DX instruction.
Definition: PPCISelLowering.h:113
llvm::PPC::MOF_RPlusSImm34
@ MOF_RPlusSImm34
Definition: PPCISelLowering.h:689
llvm::PPC::AM_DQForm
@ AM_DQForm
Definition: PPCISelLowering.h:714
llvm::PPCTargetLowering::emitEHSjLjSetJmp
MachineBasicBlock * emitEHSjLjSetJmp(MachineInstr &MI, MachineBasicBlock *MBB) const
Definition: PPCISelLowering.cpp:11417
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::PPC::AM_DSForm
@ AM_DSForm
Definition: PPCISelLowering.h:713
llvm::PPCISD::DYNALLOC
@ DYNALLOC
The following two target-specific nodes are used for calls through function pointers in the 64-bit SV...
Definition: PPCISelLowering.h:144
Results
Function Alias Analysis Results
Definition: AliasAnalysis.cpp:853
llvm::PPCTargetLowering::EmitPartwordAtomicBinary
MachineBasicBlock * EmitPartwordAtomicBinary(MachineInstr &MI, MachineBasicBlock *MBB, bool is8bit, unsigned Opcode, unsigned CmpOpcode=0, unsigned CmpPred=0) const
Definition: PPCISelLowering.cpp:11202
llvm::PPCISD::MFBHRBE
@ MFBHRBE
GPRC, CHAIN = MFBHRBE CHAIN, Entry, Dummy - Move from branch history rolling buffer entry.
Definition: PPCISelLowering.h:417
llvm::PPCTargetLowering::emitLeadingFence
Instruction * emitLeadingFence(IRBuilderBase &Builder, Instruction *Inst, AtomicOrdering Ord) const override
Inserts in the IR a target-specific intrinsic specifying a fence.
Definition: PPCISelLowering.cpp:10999
llvm::PPCTargetLowering::hasAndNotCompare
bool hasAndNotCompare(SDValue) const override
Return true if the target should transform: (X & Y) == Y —> (~X & Y) == 0 (X & Y) !...
Definition: PPCISelLowering.h:775
llvm::PPCTargetLowering::CallFlags::IsPatchPoint
const bool IsPatchPoint
Definition: PPCISelLowering.h:1125
llvm::PPC::MOF_SubtargetP10
@ MOF_SubtargetP10
Definition: PPCISelLowering.h:705
SelectionDAG.h
llvm::BitmaskEnumDetail::Mask
std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:80
llvm::PPCTargetLowering::shouldExpandBuildVectorWithShuffles
bool shouldExpandBuildVectorWithShuffles(EVT VT, unsigned DefinedValues) const override
Definition: PPCISelLowering.cpp:16410
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1567
llvm::PPCISD::LBRX
@ LBRX
GPRC, CHAIN = LBRX CHAIN, Ptr, Type - This is a byte-swapping load instruction.
Definition: PPCISelLowering.h:507
llvm::PPCISD::FCFID
@ FCFID
FCFID - The FCFID instruction, taking an f64 operand and producing and f64 value containing the FP re...
Definition: PPCISelLowering.h:61
llvm::PPCTargetLowering::expandVSXStoreForLE
SDValue expandVSXStoreForLE(SDNode *N, DAGCombinerInfo &DCI) const
Definition: PPCISelLowering.cpp:14271
llvm::PPC::isVPKUHUMShuffleMask
bool isVPKUHUMShuffleMask(ShuffleVectorSDNode *N, unsigned ShuffleKind, SelectionDAG &DAG)
isVPKUHUMShuffleMask - Return true if this is the shuffle mask for a VPKUHUM instruction.
Definition: PPCISelLowering.cpp:1776
llvm::convertToNonDenormSingle
bool convertToNonDenormSingle(APInt &ArgAPInt)
Definition: PPCISelLowering.cpp:9048
llvm::PPCISD::BDZ
@ BDZ
Definition: PPCISelLowering.h:289
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::PPCTargetLowering::PPCTargetLowering
PPCTargetLowering(const PPCTargetMachine &TM, const PPCSubtarget &STI)
Definition: PPCISelLowering.cpp:143
llvm::PPCISD::ADDI_TLSLD_L
@ ADDI_TLSLD_L
x3 = ADDI_TLSLD_L G8RReg, Symbol - For the local-dynamic TLS model, produces an ADDI8 instruction tha...
Definition: PPCISelLowering.h:376
llvm::MVT::isScalableVector
bool isScalableVector() const
Return true if this is a vector value type where the runtime length is machine dependent.
Definition: MachineValueType.h:373
llvm::PPCTargetLowering::isEqualityCmpFoldedWithSignedCmp
bool isEqualityCmpFoldedWithSignedCmp() const override
Return true if instruction generated for equality comparison is folded with instruction generated for...
Definition: PPCISelLowering.h:771
llvm::PPC::MOF_SubtargetSPE
@ MOF_SubtargetSPE
Definition: PPCISelLowering.h:706
MachineValueType.h
llvm::PPC::isXXBRWShuffleMask
bool isXXBRWShuffleMask(ShuffleVectorSDNode *N)
isXXBRWShuffleMask - Return true if this is a shuffle mask suitable for a XXBRW instruction.
Definition: PPCISelLowering.cpp:2322
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::PPCISD::UINT_VEC_TO_FP
@ UINT_VEC_TO_FP
Extract a subvector from unsigned integer vector and convert to FP.
Definition: PPCISelLowering.h:240
llvm::PPCISD::ANDI_rec_1_GT_BIT
@ ANDI_rec_1_GT_BIT
Definition: PPCISelLowering.h:255
llvm::PPCTargetLowering::CallFlags::HasNest
const bool HasNest
Definition: PPCISelLowering.h:1127
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:206
llvm::ISD::LoadExtType
LoadExtType
LoadExtType enum - This enum defines the three variants of LOADEXT (load with extension).
Definition: ISDOpcodes.h:1335
llvm::PPCISD::STXVD2X
@ STXVD2X
CHAIN = STXVD2X CHAIN, VSRC, Ptr - Occurs only for little endian.
Definition: PPCISelLowering.h:560
TargetLowering.h
llvm::Type::isArrayTy
bool isArrayTy() const
True if this is an instance of ArrayType.
Definition: Type.h:225
llvm::PPCISD::STRICT_FCTIDUZ
@ STRICT_FCTIDUZ
Definition: PPCISelLowering.h:485
llvm::PPCTargetLowering::LowerOperation
SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override
LowerOperation - Provide custom lowering hooks for some operations.
Definition: PPCISelLowering.cpp:10823
llvm::PPCISD::STFIWX
@ STFIWX
STFIWX - The STFIWX instruction.
Definition: PPCISelLowering.h:511
llvm::PPC::MOF_RPlusLo
@ MOF_RPlusLo
Definition: PPCISelLowering.h:686
llvm::PPCISD::CR6SET
@ CR6SET
ch, gl = CR6[UN]SET ch, inglue - Toggle CR bit 6 for SVR4 vararg calls
Definition: PPCISelLowering.h:307
llvm::SmallVector
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
Definition: SmallVector.h:1095
llvm::PPCTargetLowering::shouldConvertConstantLoadToIntImm
bool shouldConvertConstantLoadToIntImm(const APInt &Imm, Type *Ty) const override
Returns true if it is beneficial to convert a load of a constant to just the constant itself.
Definition: PPCISelLowering.cpp:16189
llvm::PPCISD::TC_RETURN
@ TC_RETURN
TC_RETURN - A tail call return.
Definition: PPCISelLowering.h:304
llvm::PPCISD::STRICT_FCFIDUS
@ STRICT_FCFIDUS
Definition: PPCISelLowering.h:492
llvm::PPCTargetLowering::preferIncOfAddToSubOfNot
bool preferIncOfAddToSubOfNot(EVT VT) const override
These two forms are equivalent: sub y, (xor x, -1) add (add x, 1), y The variant with two add's is IR...
Definition: PPCISelLowering.cpp:1571
llvm::PPCISD::SC
@ SC
CHAIN = SC CHAIN, Imm128 - System call.
Definition: PPCISelLowering.h:410
llvm::SelectionDAG
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Definition: SelectionDAG.h:216
SelectionDAGNodes.h
llvm::PPCISD::GlobalBaseReg
@ GlobalBaseReg
The result of the mflr at function entry, used for PIC code.
Definition: PPCISelLowering.h:156
llvm::PPCTargetLowering::isFPImmLegal
bool isFPImmLegal(const APFloat &Imm, EVT VT, bool ForCodeSize) const override
Returns true if the target can instruction select the specified FP immediate natively.
Definition: PPCISelLowering.cpp:16538
llvm::PPCSubtarget
Definition: PPCSubtarget.h:71
llvm::PPCTargetLowering::hasSPE
bool hasSPE() const
Definition: PPCISelLowering.cpp:1567
llvm::PPCTargetLowering::isDesirableToTransformToIntegerOp
bool isDesirableToTransformToIntegerOp(unsigned Opc, EVT VT) const override
Return true if it is profitable for dag combiner to transform a floating point op of specified opcode...
Definition: PPCISelLowering.h:1002
llvm::PPCISD::LFIWZX
@ LFIWZX
GPRC, CHAIN = LFIWZX CHAIN, Ptr - This is a floating-point load which zero-extends from a 32-bit inte...
Definition: PPCISelLowering.h:521
llvm::PPC::MOF_RPlusR
@ MOF_RPlusR
Definition: PPCISelLowering.h:690
llvm::PPC::MOF_ZExt
@ MOF_ZExt
Definition: PPCISelLowering.h:680
llvm::EVT
Extended Value Type.
Definition: ValueTypes.h:35
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::MVT::f64
@ f64
Definition: MachineValueType.h:56
llvm::PPCISD::XXSPLTI_SP_TO_DP
@ XXSPLTI_SP_TO_DP
XXSPLTI_SP_TO_DP - The PPC VSX splat instructions for immediates for converting immediate single prec...
Definition: PPCISelLowering.h:109
llvm::TargetLowering
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
Definition: TargetLowering.h:3170
llvm::PPCTargetLowering::ReplaceNodeResults
void ReplaceNodeResults(SDNode *N, SmallVectorImpl< SDValue > &Results, SelectionDAG &DAG) const override
ReplaceNodeResults - Replace the results of node with an illegal result type with new values built ou...
Definition: PPCISelLowering.cpp:10907
llvm::MVT::getScalarSizeInBits
uint64_t getScalarSizeInBits() const
Definition: MachineValueType.h:1062
llvm::PPCISD::VCMP_rec
@ VCMP_rec
RESVEC, OUTFLAG = VCMP_rec(LHS, RHS, OPC) - Represents one of the altivec VCMP*_rec instructions.
Definition: PPCISelLowering.h:277
llvm::PPCTargetLowering::CallFlags::CallConv
const CallingConv::ID CallConv
Definition: PPCISelLowering.h:1122
llvm::PPCTargetLowering::isLegalAddressingMode
bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty, unsigned AS, Instruction *I=nullptr) const override
isLegalAddressingMode - Return true if the addressing mode represented by AM is legal for this target...
Definition: PPCISelLowering.cpp:15900
llvm::PPCTargetLowering::CallFlags
Structure that collects some common arguments that get passed around between the functions for call l...
Definition: PPCISelLowering.h:1121
llvm::PPCTargetLowering::shouldInsertFencesForAtomic
bool shouldInsertFencesForAtomic(const Instruction *I) const override
Whether AtomicExpandPass should automatically insert fences and reduce ordering for this atomic.
Definition: PPCISelLowering.h:870
llvm::PPCISD::ATOMIC_CMP_SWAP_8
@ ATOMIC_CMP_SWAP_8
ATOMIC_CMP_SWAP - the exact same as the target-independent nodes except they ensure that the compare ...
Definition: PPCISelLowering.h:573
llvm::PPCISD::VADD_SPLAT
@ VADD_SPLAT
VRRC = VADD_SPLAT Elt, EltSize - Temporary node to be expanded during instruction selection to optimi...
Definition: PPCISelLowering.h:406
llvm::MaybeAlign
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:109
llvm::PPC::MOF_Vector
@ MOF_Vector
Definition: PPCISelLowering.h:699
llvm::PPCTargetLowering::getConstraintType
ConstraintType getConstraintType(StringRef Constraint) const override
getConstraintType - Given a constraint, return the type of constraint it is for this target.
Definition: PPCISelLowering.cpp:15604
llvm::PPCTargetLowering::getNegatedExpression
SDValue getNegatedExpression(SDValue Op, SelectionDAG &DAG, bool LegalOps, bool OptForSize, NegatibleCost &Cost, unsigned Depth=0) const override
Return the newly negated expression if the cost is not expensive and set the cost in Cost to indicate...
Definition: PPCISelLowering.cpp:16448
llvm::Instruction
Definition: Instruction.h:45
llvm::PPCTargetLowering::emitMaskedAtomicRMWIntrinsic
Value * emitMaskedAtomicRMWIntrinsic(IRBuilderBase &Builder, AtomicRMWInst *AI, Value *AlignedAddr, Value *Incr, Value *Mask, Value *ShiftAmt, AtomicOrdering Ord) const override
Perform a masked atomicrmw using a target-specific intrinsic.
Definition: PPCISelLowering.cpp:17537
llvm::PPCTargetLowering::isProfitableToHoist
bool isProfitableToHoist(Instruction *I) const override
isProfitableToHoist - Check if it is profitable to hoist instruction I to its dominator block.
Definition: PPCISelLowering.cpp:16335
llvm::InlineAsm::Constraint_es
@ Constraint_es
Definition: InlineAsm.h:245
llvm::PPCISD::SRA_ADDZE
@ SRA_ADDZE
The combination of sra[wd]i and addze used to implemented signed integer division by a power of 2.
Definition: PPCISelLowering.h:180
llvm::PPCISD::MFVSR
@ MFVSR
Direct move from a VSX register to a GPR.
Definition: PPCISelLowering.h:212
llvm::PPCTargetLowering::SelectAddressPCRel
bool SelectAddressPCRel(SDValue N, SDValue &Base) const
SelectAddressPCRel - Represent the specified address as pc relative to be represented as [pc+imm].
Definition: PPCISelLowering.cpp:2870
llvm::PPCISD::PPC32_GOT
@ PPC32_GOT
GPRC = address of GLOBAL_OFFSET_TABLE.
Definition: PPCISelLowering.h:312
llvm::PPC::isVSLDOIShuffleMask
int isVSLDOIShuffleMask(SDNode *N, unsigned ShuffleKind, SelectionDAG &DAG)
isVSLDOIShuffleMask - If this is a vsldoi shuffle mask, return the shift amount, otherwise return -1.
Definition: PPCISelLowering.cpp:2056
llvm::PPC::MOF_DoubleWordInt
@ MOF_DoubleWordInt
Definition: PPCISelLowering.h:697
llvm::PPCISD::XXSWAPD
@ XXSWAPD
VSRC, CHAIN = XXSWAPD CHAIN, VSRC - Occurs only for little endian.
Definition: PPCISelLowering.h:427
Info
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
llvm::PPCTargetLowering::CallFlags::IsIndirect
const bool IsIndirect
Definition: PPCISelLowering.h:1126
llvm::PPCISD::ADDIS_GOT_TPREL_HA
@ ADDIS_GOT_TPREL_HA
G8RC = ADDIS_GOT_TPREL_HA x2, Symbol - Used by the initial-exec TLS model, produces an ADDIS8 instruc...
Definition: PPCISelLowering.h:321
Align
uint64_t Align
Definition: ELFObjHandler.cpp:83
llvm::TargetLoweringBase::TypeWidenVector
@ TypeWidenVector
Definition: TargetLowering.h:213
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::PPCISD::SRL
@ SRL
These nodes represent PPC shifts.
Definition: PPCISelLowering.h:165
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
llvm::PPCISD::MTVSRZ
@ MTVSRZ
Direct move from a GPR to a VSX register (zero)
Definition: PPCISelLowering.h:218
Type.h
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
llvm::PPCTargetLowering::SelectOptimalAddrMode
PPC::AddrMode SelectOptimalAddrMode(const SDNode *Parent, SDValue N, SDValue &Disp, SDValue &Base, SelectionDAG &DAG, MaybeAlign Align) const
SelectOptimalAddrMode - Based on a node N and it's Parent (a MemSDNode), compute the address flags of...
Definition: PPCISelLowering.cpp:17382
llvm::PPCISD::LFIWAX
@ LFIWAX
GPRC, CHAIN = LFIWAX CHAIN, Ptr - This is a floating-point load which sign-extends from a 32-bit inte...
Definition: PPCISelLowering.h:516
llvm::PPCISD::STORE_VEC_BE
@ STORE_VEC_BE
CHAIN = STORE_VEC_BE CHAIN, VSRC, Ptr - Occurs only for little endian.
Definition: PPCISelLowering.h:565
llvm::PPCTargetLowering::getSDagStackGuard
Value * getSDagStackGuard(const Module &M) const override
Return the variable that's previously inserted by insertSSPDeclarations, if any, otherwise return nul...
Definition: PPCISelLowering.cpp:16532
llvm::PPCISD::FP_TO_SINT_IN_VSR
@ FP_TO_SINT_IN_VSR
Definition: PPCISelLowering.h:82
llvm::PPCTargetLowering::emitMaskedAtomicCmpXchgIntrinsic
Value * emitMaskedAtomicCmpXchgIntrinsic(IRBuilderBase &Builder, AtomicCmpXchgInst *CI, Value *AlignedAddr, Value *CmpVal, Value *NewVal, Value *Mask, AtomicOrdering Ord) const override
Perform a masked cmpxchg using a target-specific intrinsic.
Definition: PPCISelLowering.cpp:17562
llvm::PPCTargetLowering::getPrefLoopAlignment
Align getPrefLoopAlignment(MachineLoop *ML) const override
Return the preferred loop alignment.
Definition: PPCISelLowering.cpp:15553
llvm::CCAssignFn
bool CCAssignFn(unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, ISD::ArgFlagsTy ArgFlags, CCState &State)
CCAssignFn - This function assigns a location for Val, updating State to reflect the change.
Definition: CallingConvLower.h:177
llvm::PPCISD::XXMFACC
@ XXMFACC
XXMFACC = This corresponds to the xxmfacc instruction.
Definition: PPCISelLowering.h:480
llvm::PPCISD::FCTIWZ
@ FCTIWZ
Definition: PPCISelLowering.h:73
llvm::InlineAsm::Constraint_Z
@ Constraint_Z
Definition: InlineAsm.h:263
llvm::PPC::MOF_None
@ MOF_None
Definition: PPCISelLowering.h:676
llvm::PPCTargetLowering::hasInlineStackProbe
bool hasInlineStackProbe(MachineFunction &MF) const override
Definition: PPCISelLowering.cpp:11660
llvm::AtomicOrdering
AtomicOrdering
Atomic ordering for LLVM's memory model.
Definition: AtomicOrdering.h:56
llvm::PPCTargetLowering::SelectAddressRegRegOnly
bool SelectAddressRegRegOnly(SDValue N, SDValue &Base, SDValue &Index, SelectionDAG &DAG) const
SelectAddressRegRegOnly - Given the specified addressed, force it to be represented as an indexed [r+...
Definition: PPCISelLowering.cpp:2832
llvm::PPCISD::CALL_NOP
@ CALL_NOP
Definition: PPCISelLowering.h:187
llvm::PPC::isXXBRHShuffleMask
bool isXXBRHShuffleMask(ShuffleVectorSDNode *N)
isXXBRHShuffleMask - Return true if this is a shuffle mask suitable for a XXBRH instruction.
Definition: PPCISelLowering.cpp:2318
llvm::PPCISD::ADD_TLS
@ ADD_TLS
G8RC = ADD_TLS G8RReg, Symbol - Used by the initial-exec TLS model, produces an ADD instruction that ...
Definition: PPCISelLowering.h:335
llvm::APFloat
Definition: APFloat.h:701
llvm::PPCTargetLowering::getPICJumpTableRelocBaseExpr
const MCExpr * getPICJumpTableRelocBaseExpr(const MachineFunction *MF, unsigned JTI, MCContext &Ctx) const override
This returns the relocation base for the given PIC jumptable, the same as getPICJumpTableRelocBase,...
Definition: PPCISelLowering.cpp:3145
llvm::PPCTargetLowering::getExceptionSelectorRegister
Register getExceptionSelectorRegister(const Constant *PersonalityFn) const override
If a physical register, this returns the register that receives the exception typeid on entry to a la...
Definition: PPCISelLowering.cpp:16404
llvm::MachineLoop
Definition: MachineLoopInfo.h:45
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::PPCTargetLowering::isCheapToSpeculateCtlz
bool isCheapToSpeculateCtlz() const override
Return true if it is cheap to speculate a call to intrinsic ctlz.
Definition: PPCISelLowering.h:763
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
llvm::PPCISD::LXSIZX
@ LXSIZX
GPRC, CHAIN = LXSIZX, CHAIN, Ptr, ByteWidth - This is a load of an integer smaller than 64 bits into ...
Definition: PPCISelLowering.h:526
llvm::PPC::MOF_ScalarFloat
@ MOF_ScalarFloat
Definition: PPCISelLowering.h:698
llvm::ISD::FIRST_TARGET_STRICTFP_OPCODE
static const int FIRST_TARGET_STRICTFP_OPCODE
FIRST_TARGET_STRICTFP_OPCODE - Target-specific pre-isel operations which cannot raise FP exceptions s...
Definition: ISDOpcodes.h:1255
llvm::ISD::LOAD
@ LOAD
LOAD and STORE have token chains as their first operand, then the same operands as an LLVM load/store...
Definition: ISDOpcodes.h:921
llvm::PPCISD::MFFS
@ MFFS
F8RC = MFFS - This moves the FPSCR (not modeled) into the register.
Definition: PPCISelLowering.h:297
llvm::PPCISD::FIRST_NUMBER
@ FIRST_NUMBER
Definition: PPCISelLowering.h:48
llvm::PPC::isVMRGHShuffleMask
bool isVMRGHShuffleMask(ShuffleVectorSDNode *N, unsigned UnitSize, unsigned ShuffleKind, SelectionDAG &DAG)
isVMRGHShuffleMask - Return true if this is a shuffle mask suitable for a VRGH* instruction with the ...
Definition: PPCISelLowering.cpp:1937
llvm::PPCTargetLowering::LowerAsmOperandForConstraint
void LowerAsmOperandForConstraint(SDValue Op, std::string &Constraint, std::vector< SDValue > &Ops, SelectionDAG &DAG) const override
LowerAsmOperandForConstraint - Lower the specified operand into the Ops vector.
Definition: PPCISelLowering.cpp:15824
llvm::PPC::MOF_SExt
@ MOF_SExt
Definition: PPCISelLowering.h:679
llvm::MachinePointerInfo
This class contains a discriminated union of information about pointers in memory operands,...
Definition: MachineMemOperand.h:38
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::PPCTargetLowering::getScalarShiftAmountTy
MVT getScalarShiftAmountTy(const DataLayout &, EVT) const override
EVT is not used in-tree, but is used by out-of-tree target.
Definition: PPCISelLowering.h:755
PPCInstrInfo.h
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::PPC::AddrMode
AddrMode
Definition: PPCISelLowering.h:710
llvm::PPCTargetLowering::getRegisterByName
Register getRegisterByName(const char *RegName, LLT VT, const MachineFunction &MF) const override
Return the register ID of the name passed in.
Definition: PPCISelLowering.cpp:16008
llvm::PPCTargetLowering::enableAggressiveFMAFusion
bool enableAggressiveFMAFusion(EVT VT) const override
Return true if target always benefits from combining into FMA for a given value type.
Definition: PPCISelLowering.cpp:1742
llvm::TargetLoweringBase::NegatibleCost
NegatibleCost
Enum that specifies when a float negation is beneficial.
Definition: TargetLowering.h:267
llvm::PPCISD::SRA
@ SRA
Definition: PPCISelLowering.h:166
llvm::PPCISD::Hi
@ Hi
Hi/Lo - These represent the high and low 16-bit parts of a global address respectively.
Definition: PPCISelLowering.h:135
llvm::MachineMemOperand::Flags
Flags
Flags values. These may be or'd together.
Definition: MachineMemOperand.h:131
llvm::MVT::getVectorNumElements
unsigned getVectorNumElements() const
Definition: MachineValueType.h:850
llvm::PPCISD::PROBED_ALLOCA
@ PROBED_ALLOCA
To avoid stack clash, allocation is performed by block and each block is probed.
Definition: PPCISelLowering.h:153
llvm::PPCTargetLowering::getStackProbeSize
unsigned getStackProbeSize(MachineFunction &MF) const
Definition: PPCISelLowering.cpp:11668
llvm::PPCISD::EXTRACT_SPE
@ EXTRACT_SPE
Extract SPE register component, second argument is high or low.
Definition: PPCISelLowering.h:230
llvm::PPCISD::EH_SJLJ_LONGJMP
@ EH_SJLJ_LONGJMP
Definition: PPCISelLowering.h:265
llvm::FunctionLoweringInfo
FunctionLoweringInfo - This contains information that is global to a function that is used when lower...
Definition: FunctionLoweringInfo.h:53
llvm::PPCTargetLowering::allowsMisalignedMemoryAccesses
bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AddrSpace, Align Alignment=Align(1), MachineMemOperand::Flags Flags=MachineMemOperand::MONone, bool *Fast=nullptr) const override
Is unaligned memory access allowed for the given type, and is it fast relative to software emulation.
Definition: PPCISelLowering.cpp:16250
llvm::PPC::MOF_PCRel
@ MOF_PCRel
Definition: PPCISelLowering.h:691
llvm::PPCISD::BUILD_FP128
@ BUILD_FP128
Direct move of 2 consecutive GPR to a VSX register.
Definition: PPCISelLowering.h:221
Mode
SI Whole Quad Mode
Definition: SIWholeQuadMode.cpp:262
llvm::PPCTargetLowering::getSetCCResultType
EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context, EVT VT) const override
getSetCCResultType - Return the ISD::SETCC ValueType
Definition: PPCISelLowering.cpp:1734
llvm::MVT
Machine Value Type.
Definition: MachineValueType.h:31
llvm::PPCISD::EXTRACT_VSX_REG
@ EXTRACT_VSX_REG
EXTRACT_VSX_REG = Extract one of the underlying vsx registers of an accumulator or pair register.
Definition: PPCISelLowering.h:477
llvm::FastISel
This is a fast-path instruction selection class that generates poor code and doesn't support illegal ...
Definition: FastISel.h:65
llvm::PPCTargetLowering
Definition: PPCISelLowering.h:719
llvm::PPCTargetLowering::getExceptionPointerRegister
Register getExceptionPointerRegister(const Constant *PersonalityFn) const override
If a physical register, this returns the register that receives the exception address on entry to an ...
Definition: PPCISelLowering.cpp:16399
llvm::PPC::MemOpFlags
MemOpFlags
Definition: PPCISelLowering.h:675
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::PPCISD::DYNAREAOFFSET
@ DYNAREAOFFSET
This instruction is lowered in PPCRegisterInfo::eliminateFrameIndex to compute an offset from native ...
Definition: PPCISelLowering.h:149
llvm::MDNode
Metadata node.
Definition: Metadata.h:897
llvm::PPCTargetLowering::isOffsetFoldingLegal
bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override
Return true if folding a constant offset with the given GlobalAddress is legal.
Definition: PPCISelLowering.cpp:16054
llvm::PPC::isVMRGEOShuffleMask
bool isVMRGEOShuffleMask(ShuffleVectorSDNode *N, bool CheckEven, unsigned ShuffleKind, SelectionDAG &DAG)
isVMRGEOShuffleMask - Return true if this is a shuffle mask suitable for a VMRGEW or VMRGOW instructi...
Definition: PPCISelLowering.cpp:2027
info
lazy value info
Definition: LazyValueInfo.cpp:59
Builder
assume Assume Builder
Definition: AssumeBundleBuilder.cpp:651
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:70
llvm::MachineFunction
Definition: MachineFunction.h:230
llvm::isIntS16Immediate
bool isIntS16Immediate(SDNode *N, int16_t &Imm)
isIntS16Immediate - This method tests to see if the node is either a 32-bit or 64-bit immediate,...
Definition: PPCISelLowering.cpp:2520
llvm::PPCISD::SCALAR_TO_VECTOR_PERMUTED
@ SCALAR_TO_VECTOR_PERMUTED
PowerPC instructions that have SCALAR_TO_VECTOR semantics tend to place the value into the least sign...
Definition: PPCISelLowering.h:248
llvm::PPCISD::STRICT_FCFIDU
@ STRICT_FCFIDU
Definition: PPCISelLowering.h:490
llvm::PPCTargetLowering::emitEHSjLjLongJmp
MachineBasicBlock * emitEHSjLjLongJmp(MachineInstr &MI, MachineBasicBlock *MBB) const
Definition: PPCISelLowering.cpp:11559
llvm::PPCTargetLowering::functionArgumentNeedsConsecutiveRegisters
bool functionArgumentNeedsConsecutiveRegisters(Type *Ty, CallingConv::ID CallConv, bool isVarArg, const DataLayout &DL) const override
Returns true if an argument of type Ty needs to be passed in a contiguous block of registers in calli...
Definition: PPCISelLowering.h:1068
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::PPCISD::VCMP
@ VCMP
RESVEC = VCMP(LHS, RHS, OPC) - Represents one of the altivec VCMP* instructions.
Definition: PPCISelLowering.h:271
llvm::PPCISD::STRICT_FADDRTZ
@ STRICT_FADDRTZ
Constrained floating point add in round-to-zero mode.
Definition: PPCISelLowering.h:495
llvm::PPCISD::STRICT_FCFIDS
@ STRICT_FCFIDS
Definition: PPCISelLowering.h:491
llvm::PPCTargetLowering::SelectAddressEVXRegReg
bool SelectAddressEVXRegReg(SDValue N, SDValue &Base, SDValue &Index, SelectionDAG &DAG) const
SelectAddressEVXRegReg - Given the specified addressed, check to see if it can be more efficiently re...
Definition: PPCISelLowering.cpp:2551
llvm::IRBuilderBase
Common base class shared among various IRBuilders.
Definition: IRBuilder.h:95
llvm::PPCTargetLowering::SelectAddressRegImm34
bool SelectAddressRegImm34(SDValue N, SDValue &Disp, SDValue &Base, SelectionDAG &DAG) const
Similar to the 16-bit case but for instructions that take a 34-bit displacement field (prefixed loads...
Definition: PPCISelLowering.cpp:2783
llvm::PPCTargetLowering::CallFlags::IsTailCall
const bool IsTailCall
Definition: PPCISelLowering.h:1123
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::PPCISD::FCFIDUS
@ FCFIDUS
Definition: PPCISelLowering.h:67
AddrMode
AddrMode
Definition: MSP430Disassembler.cpp:142
llvm::ISD::BUILTIN_OP_END
@ BUILTIN_OP_END
BUILTIN_OP_END - This must be the last enum value in this list.
Definition: ISDOpcodes.h:1249
llvm::PPCISD::PPC32_PICGOT
@ PPC32_PICGOT
GPRC = address of GLOBAL_OFFSET_TABLE.
Definition: PPCISelLowering.h:316
llvm::PPCISD::LXVRZX
@ LXVRZX
LXVRZX - Load VSX Vector Rightmost and Zero Extend This node represents v1i128 BUILD_VECTOR of a zero...
Definition: PPCISelLowering.h:542
llvm::PPCISD::LD_VSX_LH
@ LD_VSX_LH
VSRC, CHAIN = LD_VSX_LH CHAIN, Ptr - This is a floating-point load of a v2f32 value into the lower ha...
Definition: PPCISelLowering.h:551
llvm::PPC::getSplatIdxForPPCMnemonics
unsigned getSplatIdxForPPCMnemonics(SDNode *N, unsigned EltSize, SelectionDAG &DAG)
getSplatIdxForPPCMnemonics - Return the splat index as a value that is appropriate for PPC mnemonics ...
Definition: PPCISelLowering.cpp:2398
llvm::PPCTargetLowering::isJumpTableRelative
bool isJumpTableRelative() const override
Definition: PPCISelLowering.cpp:3121
llvm::PPCISD::PADDI_DTPREL
@ PADDI_DTPREL
G8RC = PADDI_DTPREL x3, Symbol - For the pc-rel based local-dynamic TLS model, produces a PADDI8 inst...
Definition: PPCISelLowering.h:400
llvm::AtomicRMWInst
an instruction that atomically reads a memory location, combines it with another value,...
Definition: Instructions.h:726
llvm::PPCTargetLowering::EmitAtomicBinary
MachineBasicBlock * EmitAtomicBinary(MachineInstr &MI, MachineBasicBlock *MBB, unsigned AtomicSize, unsigned BinOpcode, unsigned CmpOpcode=0, unsigned CmpPred=0) const
Definition: PPCISelLowering.cpp:11029
llvm::PPC::AM_XForm
@ AM_XForm
Definition: PPCISelLowering.h:715
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::PPCTargetLowering::getScratchRegisters
const MCPhysReg * getScratchRegisters(CallingConv::ID CC) const override
Returns a 0 terminated array of registers that can be safely used as scratch registers.
Definition: PPCISelLowering.cpp:16387
llvm::PPCISD::LXVD2X
@ LXVD2X
VSRC, CHAIN = LXVD2X_LE CHAIN, Ptr - Occurs only for little endian.
Definition: PPCISelLowering.h:536
llvm::PPCISD::ADDIS_TLSGD_HA
@ ADDIS_TLSGD_HA
G8RC = ADDIS_TLSGD_HA x2, Symbol - For the general-dynamic TLS model, produces an ADDIS8 instruction ...
Definition: PPCISelLowering.h:340
llvm::PPCISD::ADDI_DTPREL_L
@ ADDI_DTPREL_L
G8RC = ADDI_DTPREL_L G8RReg, Symbol - For the local-dynamic TLS model, produces an ADDI8 instruction ...
Definition: PPCISelLowering.h:396
llvm::PPC::isVPKUDUMShuffleMask
bool isVPKUDUMShuffleMask(ShuffleVectorSDNode *N, unsigned ShuffleKind, SelectionDAG &DAG)
isVPKUDUMShuffleMask - Return true if this is the shuffle mask for a VPKUDUM instruction.
Definition: PPCISelLowering.cpp:1844
llvm::PPCISD::FCTIWUZ
@ FCTIWUZ
Definition: PPCISelLowering.h:78
llvm::PPCTargetLowering::isFPExtFree
bool isFPExtFree(EVT DestVT, EVT SrcVT) const override
Return true if an fpext operation is free (for instance, because single-precision floating-point numb...
Definition: PPCISelLowering.cpp:16233
CallingConv.h
llvm::PPCISD::ADDI_TLSLD_L_ADDR
@ ADDI_TLSLD_L_ADDR
G8RC = ADDI_TLSLD_L_ADDR G8RReg, Symbol, Symbol - Op that combines ADDI_TLSLD_L and GET_TLSLD_ADDR un...
Definition: PPCISelLowering.h:386
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
Attributes.h
llvm::PPCISD::FSEL
@ FSEL
FSEL - Traditional three-operand fsel node.
Definition: PPCISelLowering.h:52
llvm::PPCISD::RET_FLAG
@ RET_FLAG
Return with a flag operand, matched by 'blr'.
Definition: PPCISelLowering.h:204
llvm::PPCISD::TOC_ENTRY
@ TOC_ENTRY
GPRC = TOC_ENTRY GA, TOC Loads the entry for GA from the TOC, where the TOC base is given by the last...
Definition: PPCISelLowering.h:579
llvm::PPCTargetLowering::CallFlags::IsVarArg
const bool IsVarArg
Definition: PPCISelLowering.h:1124
llvm::PPC::isXXBRQShuffleMask
bool isXXBRQShuffleMask(ShuffleVectorSDNode *N)
isXXBRQShuffleMask - Return true if this is a shuffle mask suitable for a XXBRQ instruction.
Definition: PPCISelLowering.cpp:2330
llvm::PPCISD::STRICT_FCTIWUZ
@ STRICT_FCTIWUZ
Definition: PPCISelLowering.h:486
llvm::PPC::createFastISel
FastISel * createFastISel(FunctionLoweringInfo &FuncInfo, const TargetLibraryInfo *LibInfo)
Definition: PPCFastISel.cpp:2468
llvm::PPCTargetLowering::SelectAddressRegImm
bool SelectAddressRegImm(SDValue N, SDValue &Disp, SDValue &Base, SelectionDAG &DAG, MaybeAlign EncodingAlignment) const
SelectAddressRegImm - Returns true if the address N can be represented by a base register plus a sign...
Definition: PPCISelLowering.cpp:2678
llvm::GlobalAddressSDNode
Definition: SelectionDAGNodes.h:1700
llvm::KnownBits
Definition: KnownBits.h:23
llvm::TargetLoweringBase::AtomicExpansionKind
AtomicExpansionKind
Enum that specifies what an atomic load/AtomicRMWInst is expanded to, if at all.
Definition: TargetLowering.h:249
uint16_t
llvm::PPCISD::STBRX
@ STBRX
CHAIN = STBRX CHAIN, GPRC, Ptr, Type - This is a byte-swapping store instruction.
Definition: PPCISelLowering.h:501
CallingConvLower.h
llvm::PPCISD::XSMAXCDP
@ XSMAXCDP
XSMAXCDP, XSMINCDP - C-type min/max instructions.
Definition: PPCISelLowering.h:55
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:314
llvm::PPCTargetLowering::useLoadStackGuardNode
bool useLoadStackGuardNode() const override
Override to support customized stack guard loading.
Definition: PPCISelLowering.cpp:16514
llvm::TargetLowering::ConstraintWeight
ConstraintWeight
Definition: TargetLowering.h:4147
llvm::PPCISD::FCTIDUZ
@ FCTIDUZ
Newer FCTI[D,W]UZ floating-point-to-integer conversion instructions for unsigned integers with round ...
Definition: PPCISelLowering.h:77
llvm::PPCISD::ADDIS_DTPREL_HA
@ ADDIS_DTPREL_HA
G8RC = ADDIS_DTPREL_HA x3, Symbol - For the local-dynamic TLS model, produces an ADDIS8 instruction t...
Definition: PPCISelLowering.h:391
llvm::PPCISD::ANDI_rec_1_EQ_BIT
@ ANDI_rec_1_EQ_BIT
i1 = ANDI_rec_1_[EQ|GT]_BIT(i32 or i64 x) - Represents the result of the eq or gt bit of CR0 after ex...
Definition: PPCISelLowering.h:254
llvm::PPCTargetLowering::BuildSDIVPow2
SDValue BuildSDIVPow2(SDNode *N, const APInt &Divisor, SelectionDAG &DAG, SmallVectorImpl< SDNode * > &Created) const override
Targets may override this function to provide custom SDIV lowering for power-of-2 denominators.
Definition: PPCISelLowering.cpp:15477
Function.h
llvm::PPCTargetLowering::isLegalAddImmediate
bool isLegalAddImmediate(int64_t Imm) const override
isLegalAddImmediate - Return true if the specified immediate is legal add immediate,...
Definition: PPCISelLowering.cpp:16246
llvm::PPC::MOF_SubWordInt
@ MOF_SubWordInt
Definition: PPCISelLowering.h:695
llvm::PPCISD::SWAP_NO_CHAIN
@ SWAP_NO_CHAIN
An SDNode for swaps that are not associated with any loads/stores and thereby have no chain.
Definition: PPCISelLowering.h:431
llvm::MVT::i32
@ i32
Definition: MachineValueType.h:46
llvm::TargetLoweringBase::LegalizeTypeAction
LegalizeTypeAction
This enum indicates whether a types are legal for a target, and if not, what action should be used to...
Definition: TargetLowering.h:205
llvm::TargetLibraryInfo
Provides information about what library functions are available for the current target.
Definition: TargetLibraryInfo.h:219
llvm::PPCISD::NodeType
NodeType
Definition: PPCISelLowering.h:46
llvm::SDValue
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation.
Definition: SelectionDAGNodes.h:138
llvm::PPC::isVPKUWUMShuffleMask
bool isVPKUWUMShuffleMask(ShuffleVectorSDNode *N, unsigned ShuffleKind, SelectionDAG &DAG)
isVPKUWUMShuffleMask - Return true if this is the shuffle mask for a VPKUWUM instruction.
Definition: PPCISelLowering.cpp:1807
llvm::PPCISD::CALL
@ CALL
CALL - A direct function call.
Definition: PPCISelLowering.h:186
llvm::PPCISD::CR6UNSET
@ CR6UNSET
Definition: PPCISelLowering.h:308
llvm::PPCTargetLowering::insertSSPDeclarations
void insertSSPDeclarations(Module &M) const override
Inserts necessary declarations for SSP (stack protection) purpose.
Definition: PPCISelLowering.cpp:16522
llvm::TargetLoweringBase::getSchedulingPreference
Sched::Preference getSchedulingPreference() const
Return target scheduling preference.
Definition: TargetLowering.h:838
llvm::PPCISD::BCTRL_LOAD_TOC
@ BCTRL_LOAD_TOC
CHAIN,FLAG = BCTRL(CHAIN, ADDR, INFLAG) - The combination of a bctrl instruction and the TOC reload r...
Definition: PPCISelLowering.h:201
llvm::PPC::MOF_RPlusSImm16Mult4
@ MOF_RPlusSImm16Mult4
Definition: PPCISelLowering.h:687
llvm::PPCTargetLowering::isCheapToSpeculateCttz
bool isCheapToSpeculateCttz() const override
Return true if it is cheap to speculate a call to intrinsic cttz.
Definition: PPCISelLowering.h:759
llvm::PPCTargetLowering::CallFlags::CallFlags
CallFlags(CallingConv::ID CC, bool IsTailCall, bool IsVarArg, bool IsPatchPoint, bool IsIndirect, bool HasNest, bool NoMerge)
Definition: PPCISelLowering.h:1130
llvm::PPCISD::LOAD_VEC_BE
@ LOAD_VEC_BE
VSRC, CHAIN = LOAD_VEC_BE CHAIN, Ptr - Occurs only for little endian.
Definition: PPCISelLowering.h:547
llvm::PPCTargetMachine
Common code between 32-bit and 64-bit PowerPC targets.
Definition: PPCTargetMachine.h:25
llvm::ISD::STORE
@ STORE
Definition: ISDOpcodes.h:922
llvm::PPCISD::ADDIS_TLSLD_HA
@ ADDIS_TLSLD_HA
G8RC = ADDIS_TLSLD_HA x2, Symbol - For the local-dynamic TLS model, produces an ADDIS8 instruction th...
Definition: PPCISelLowering.h:370
llvm::PPC::MOF_WordInt
@ MOF_WordInt
Definition: PPCISelLowering.h:696
llvm::PPCISD::ADDI_TLSGD_L
@ ADDI_TLSGD_L
x3 = ADDI_TLSGD_L G8RReg, Symbol - For the general-dynamic TLS model, produces an ADDI8 instruction t...
Definition: PPCISelLowering.h:346
llvm::checkConvertToNonDenormSingle
bool checkConvertToNonDenormSingle(APFloat &ArgAPFloat)
Definition: PPCISelLowering.cpp:9058
llvm::PPCTargetLowering::isTruncateFree
bool isTruncateFree(Type *Ty1, Type *Ty2) const override
isTruncateFree - Return true if it's free to truncate a value of type Ty1 to type Ty2.
Definition: PPCISelLowering.cpp:16197
llvm::PPCISD::EXTSWSLI
@ EXTSWSLI
EXTSWSLI = The PPC extswsli instruction, which does an extend-sign word and shift left immediate.
Definition: PPCISelLowering.h:174
llvm::InlineAsm::Constraint_Zy
@ Constraint_Zy
Definition: InlineAsm.h:265
llvm::PPCISD::TLSGD_AIX
@ TLSGD_AIX
GPRC = TLSGD_AIX, TOC_ENTRY, TOC_ENTRY G8RC = TLSGD_AIX, TOC_ENTRY, TOC_ENTRY Op that combines two re...
Definition: PPCISelLowering.h:365
llvm::PPC::MOF_RPlusSImm16
@ MOF_RPlusSImm16
Definition: PPCISelLowering.h:685
llvm::PPCISD::MFOCRF
@ MFOCRF
R32 = MFOCRF(CRREG, INFLAG) - Represents the MFOCRF instruction.
Definition: PPCISelLowering.h:209
llvm::PPC::isVMRGLShuffleMask
bool isVMRGLShuffleMask(ShuffleVectorSDNode *N, unsigned UnitSize, unsigned ShuffleKind, SelectionDAG &DAG)
isVMRGLShuffleMask - Return true if this is a shuffle mask suitable for a VRGL* instruction with the ...
Definition: PPCISelLowering.cpp:1912
llvm::PPCISD::VECINSERT
@ VECINSERT
VECINSERT - The PPC vector insert instruction.
Definition: PPCISelLowering.h:117
llvm::PPCISD::CALL_NOTOC
@ CALL_NOTOC
Definition: PPCISelLowering.h:188
llvm::PPCTargetLowering::emitTrailingFence
Instruction * emitTrailingFence(IRBuilderBase &Builder, Instruction *Inst, AtomicOrdering Ord) const override
Definition: PPCISelLowering.cpp:11009
llvm::PPCISD::SINT_VEC_TO_FP
@ SINT_VEC_TO_FP
Extract a subvector from signed integer vector and convert to FP.
Definition: PPCISelLowering.h:236
llvm::PPCISD::LD_SPLAT
@ LD_SPLAT
VSRC, CHAIN = LD_SPLAT, CHAIN, Ptr - a splatting load memory instructions such as LXVDSX,...
Definition: PPCISelLowering.h:555
llvm::PPCISD::SHL
@ SHL
Definition: PPCISelLowering.h:167
llvm::PPCISD::VEXTS
@ VEXTS
VEXTS, ByteWidth - takes an input in VSFRC and produces an output in VSFRC that is sign-extended from...
Definition: PPCISelLowering.h:86
llvm::ISD::FIRST_TARGET_MEMORY_OPCODE
static const int FIRST_TARGET_MEMORY_OPCODE
FIRST_TARGET_MEMORY_OPCODE - Target-specific pre-isel operations which do not reference a specific me...
Definition: ISDOpcodes.h:1261
N
#define N
llvm::PPCTargetLowering::decomposeMulByConstant
bool decomposeMulByConstant(LLVMContext &Context, EVT VT, SDValue C) const override
Return true if it is profitable to transform an integer multiplication-by-constant into simpler opera...
Definition: PPCISelLowering.cpp:16288
llvm::PPCTargetLowering::SelectForceXFormMode
PPC::AddrMode SelectForceXFormMode(SDValue N, SDValue &Disp, SDValue &Base, SelectionDAG &DAG) const
SelectForceXFormMode - Given the specified address, force it to be represented as an indexed [r+r] op...
Definition: PPCISelLowering.cpp:17334
llvm::PPCTargetLowering::EmitInstrWithCustomInserter
MachineBasicBlock * EmitInstrWithCustomInserter(MachineInstr &MI, MachineBasicBlock *MBB) const override
This method should be implemented by targets that mark instructions with the 'usesCustomInserter' fla...
Definition: PPCISelLowering.cpp:11855
llvm::PPCTargetLowering::isZExtFree
bool isZExtFree(SDValue Val, EVT VT2) const override
Return true if zero-extending the specific node Val to type VT2 is free (either because it's implicit...
Definition: PPCISelLowering.cpp:16213
llvm::PPCISD::PAIR_BUILD
@ PAIR_BUILD
PAIR_BUILD = Build a vector pair register from 2 VSX registers.
Definition: PPCISelLowering.h:471
llvm::TargetLowering::getInlineAsmMemConstraint
virtual unsigned getInlineAsmMemConstraint(StringRef ConstraintCode) const
Definition: TargetLowering.h:4239
llvm::PPCTargetLowering::useSoftFloat
bool useSoftFloat() const override
Definition: PPCISelLowering.cpp:1563
llvm::PPCISD::FRE
@ FRE
Reciprocal estimate instructions (unary FP ops).
Definition: PPCISelLowering.h:89
llvm::PPCISD::ST_VSR_SCAL_INT
@ ST_VSR_SCAL_INT
Store scalar integers from VSR.
Definition: PPCISelLowering.h:568
llvm::PPCTargetLowering::shouldExpandAtomicCmpXchgInIR
TargetLowering::AtomicExpansionKind shouldExpandAtomicCmpXchgInIR(AtomicCmpXchgInst *AI) const override
Returns how the given atomic cmpxchg should be expanded by the IR-level AtomicExpand pass.
Definition: PPCISelLowering.cpp:17505
llvm::PPCISD::XXPERMDI
@ XXPERMDI
XXPERMDI - The PPC XXPERMDI instruction.
Definition: PPCISelLowering.h:125
PPC
should just be implemented with a CLZ instruction Since there are other e PPC
Definition: README.txt:709
llvm::MipsISD::Ins
@ Ins
Definition: MipsISelLowering.h:157
llvm::PPC::MOF_NoExt
@ MOF_NoExt
Definition: PPCISelLowering.h:681
MachineMemOperand.h
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:43
llvm::PPC::MOF_Vector256
@ MOF_Vector256
Definition: PPCISelLowering.h:700
llvm::PPCISD::GET_TLS_ADDR
@ GET_TLS_ADDR
x3 = GET_TLS_ADDR x3, Symbol - For the general-dynamic TLS model, produces a call to __tls_get_addr(s...
Definition: PPCISelLowering.h:351
RegName
#define RegName(no)
llvm::PPCISD::BCTRL
@ BCTRL
CHAIN,FLAG = BCTRL(CHAIN, INFLAG) - Directly corresponds to a BCTRL instruction.
Definition: PPCISelLowering.h:196
llvm::PPCTargetLowering::createFastISel
FastISel * createFastISel(FunctionLoweringInfo &FuncInfo, const TargetLibraryInfo *LibInfo) const override
createFastISel - This method returns a target-specific FastISel object, or null if the target does no...
Definition: PPCISelLowering.cpp:16430
llvm::PPCTargetLowering::getInlineAsmMemConstraint
unsigned getInlineAsmMemConstraint(StringRef ConstraintCode) const override
Definition: PPCISelLowering.h:950
llvm::PPC::MOF_AddrIsSImm32
@ MOF_AddrIsSImm32
Definition: PPCISelLowering.h:692
TM
const char LLVMTargetMachineRef TM
Definition: PassBuilderBindings.cpp:47
llvm::TargetLoweringBase::Enabled
@ Enabled
Definition: TargetLowering.h:490
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1475
llvm::PPCISD::CMPB
@ CMPB
The CMPB instruction (takes two operands of i32 or i64).
Definition: PPCISelLowering.h:128
llvm::PPCISD::GET_TLSLD_ADDR
@ GET_TLSLD_ADDR
x3 = GET_TLSLD_ADDR x3, Symbol - For the local-dynamic TLS model, produces a call to __tls_get_addr(s...
Definition: PPCISelLowering.h:381
llvm::PPCTargetLowering::convertSelectOfConstantsToMath
bool convertSelectOfConstantsToMath(EVT VT) const override
Return true if a select of constants (select Cond, C1, C2) should be transformed into simple math ops...
Definition: PPCISelLowering.h:995
llvm::PPCISD::ATOMIC_CMP_SWAP_16
@ ATOMIC_CMP_SWAP_16
Definition: PPCISelLowering.h:574
llvm::PPCTargetLowering::convertSetCCLogicToBitwiseLogic
bool convertSetCCLogicToBitwiseLogic(EVT VT) const override
Use bitwise logic to make pairs of compares more efficient.
Definition: PPCISelLowering.h:781
llvm::PPCISD::FP_TO_UINT_IN_VSR
@ FP_TO_UINT_IN_VSR
Floating-point-to-interger conversion instructions.
Definition: PPCISelLowering.h:81
llvm::Sched::Preference
Preference
Definition: TargetLowering.h:97
llvm::PPC::get_VSPLTI_elt
SDValue get_VSPLTI_elt(SDNode *N, unsigned ByteSize, SelectionDAG &DAG)
get_VSPLTI_elt - If this is a build_vector of constants which can be formed by using a vspltis[bhw] i...
Definition: PPCISelLowering.cpp:2412
llvm::PPCTargetLowering::getRegForInlineAsmConstraint
std::pair< unsigned, const TargetRegisterClass * > getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI, StringRef Constraint, MVT VT) const override
Given a physical register constraint (e.g.
Definition: PPCISelLowering.cpp:15694
llvm::PPC::MOF_SubtargetBeforeP9
@ MOF_SubtargetBeforeP9
Definition: PPCISelLowering.h:703
llvm::PPCISD::STRICT_FCFID
@ STRICT_FCFID
Constrained integer-to-floating-point conversion instructions.
Definition: PPCISelLowering.h:489
llvm::PPCISD::FTSQRT
@ FTSQRT
Test instruction for software square root.
Definition: PPCISelLowering.h:93
llvm::PPCTargetLowering::getTargetNodeName
const char * getTargetNodeName(unsigned Opcode) const override
getTargetNodeName() - This method returns the name of a target specific DAG node.
Definition: PPCISelLowering.cpp:1575
MachineFunction.h
llvm::PPCISD::EH_SJLJ_SETJMP
@ EH_SJLJ_SETJMP
Definition: PPCISelLowering.h:262
llvm::PPCTargetLowering::isLegalICmpImmediate
bool isLegalICmpImmediate(int64_t Imm) const override
isLegalICmpImmediate - Return true if the specified immediate is legal icmp immediate,...
Definition: PPCISelLowering.cpp:16242
llvm::MachineMemOperand::MONone
@ MONone
Definition: MachineMemOperand.h:133
llvm::PPCTargetLowering::isFMAFasterThanFMulAndFAdd
bool isFMAFasterThanFMulAndFAdd(const MachineFunction &MF, EVT VT) const override
isFMAFasterThanFMulAndFAdd - Return true if an FMA operation is faster than a pair of fmul and fadd i...
Definition: PPCISelLowering.cpp:16315
llvm::PPCTargetLowering::PerformDAGCombine
SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override
This method will be invoked for all target nodes and for any target-independent nodes that the target...
Definition: PPCISelLowering.cpp:14727
llvm::MVT::f32
@ f32
Definition: MachineValueType.h:55
llvm::PPCTargetLowering::isSelectSupported
bool isSelectSupported(SelectSupportKind Kind) const override
Definition: PPCISelLowering.h:730
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::AtomicCmpXchgInst
An instruction that atomically checks whether a specified value is in a memory location,...
Definition: Instructions.h:521
llvm::PPCISD::TLS_LOCAL_EXEC_MAT_ADDR
@ TLS_LOCAL_EXEC_MAT_ADDR
TLS_LOCAL_EXEC_MAT_ADDR = Materialize an address for TLS global address when using local exec access ...
Definition: PPCISelLowering.h:465
llvm::MCExpr
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
llvm::PPCISD::ADDI_TLSGD_L_ADDR
@ ADDI_TLSGD_L_ADDR
G8RC = ADDI_TLSGD_L_ADDR G8RReg, Symbol, Symbol - Op that combines ADDI_TLSGD_L and GET_TLS_ADDR unti...
Definition: PPCISelLowering.h:356
llvm::PPCISD::STRICT_FCTIWZ
@ STRICT_FCTIWZ
Definition: PPCISelLowering.h:484
llvm::TargetLoweringBase::SelectSupportKind
SelectSupportKind
Enum that describes what type of support for selects the target has.
Definition: TargetLowering.h:237
llvm::PPCISD::COND_BRANCH
@ COND_BRANCH
CHAIN = COND_BRANCH CHAIN, CRRC, OPC, DESTBB [, INFLAG] - This corresponds to the COND_BRANCH pseudo ...
Definition: PPCISelLowering.h:284
llvm::PPCTargetLowering::emitProbedAlloca
MachineBasicBlock * emitProbedAlloca(MachineInstr &MI, MachineBasicBlock *MBB) const
Definition: PPCISelLowering.cpp:11693
llvm::PPCISD::TLS_DYNAMIC_MAT_PCREL_ADDR
@ TLS_DYNAMIC_MAT_PCREL_ADDR
TLS_DYNAMIC_MAT_PCREL_ADDR = Materialize a PC Relative address for TLS global address when using dyna...
Definition: PPCISelLowering.h:460
llvm::PPCTargetLowering::getByValTypeAlignment
unsigned getByValTypeAlignment(Type *Ty, const DataLayout &DL) const override
getByValTypeAlignment - Return the desired alignment for ByVal aggregate function arguments in the ca...
Definition: PPCISelLowering.cpp:1553
llvm::sampleprof::Base
@ Base
Definition: Discriminator.h:58
llvm::PPCISD::FRSQRTE
@ FRSQRTE
Definition: PPCISelLowering.h:90
llvm::PPCISD::VECSHL
@ VECSHL
VECSHL - The PPC vector shift left instruction.
Definition: PPCISelLowering.h:121
llvm::PPCISD::FCFIDS
@ FCFIDS
Definition: PPCISelLowering.h:66
llvm::LLT
Definition: LowLevelTypeImpl.h:40