2007-01-19 07:51:42 +00:00
|
|
|
//===-- ARMISelLowering.h - ARM DAG Lowering Interface ----------*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2007-01-19 07:51:42 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file defines the interfaces that ARM uses to lower LLVM code into a
|
|
|
|
// selection DAG.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef ARMISELLOWERING_H
|
|
|
|
#define ARMISELLOWERING_H
|
|
|
|
|
2007-11-05 23:12:20 +00:00
|
|
|
#include "ARMSubtarget.h"
|
2007-01-19 07:51:42 +00:00
|
|
|
#include "llvm/Target/TargetLowering.h"
|
|
|
|
#include "llvm/CodeGen/SelectionDAG.h"
|
2009-04-17 19:07:39 +00:00
|
|
|
#include "llvm/CodeGen/CallingConvLower.h"
|
2007-01-19 07:51:42 +00:00
|
|
|
#include <vector>
|
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
class ARMConstantPoolValue;
|
|
|
|
|
|
|
|
namespace ARMISD {
|
|
|
|
// ARM Specific DAG Nodes
|
|
|
|
enum NodeType {
|
2009-05-13 22:32:43 +00:00
|
|
|
// Start the numbering where the builtin ops and target ops leave off.
|
2008-09-23 18:42:32 +00:00
|
|
|
FIRST_NUMBER = ISD::BUILTIN_OP_END,
|
2007-01-19 07:51:42 +00:00
|
|
|
|
|
|
|
Wrapper, // Wrapper - A wrapper node for TargetConstantPool,
|
|
|
|
// TargetExternalSymbol, and TargetGlobalAddress.
|
|
|
|
WrapperJT, // WrapperJT - A wrapper node for TargetJumpTable
|
2009-05-13 22:32:43 +00:00
|
|
|
|
2007-01-19 07:51:42 +00:00
|
|
|
CALL, // Function call.
|
2007-06-19 21:05:09 +00:00
|
|
|
CALL_PRED, // Function call that's predicable.
|
2007-01-19 07:51:42 +00:00
|
|
|
CALL_NOLINK, // Function call with branch not branch-and-link.
|
|
|
|
tCALL, // Thumb function call.
|
|
|
|
BRCOND, // Conditional branch.
|
|
|
|
BR_JT, // Jumptable branch.
|
2009-07-29 02:18:14 +00:00
|
|
|
BR2_JT, // Jumptable branch (2 level - jumptable entry is a jump).
|
2007-01-19 07:51:42 +00:00
|
|
|
RET_FLAG, // Return with a flag operand.
|
|
|
|
|
|
|
|
PIC_ADD, // Add with a PC operand and a PIC label.
|
|
|
|
|
|
|
|
CMP, // ARM compare instructions.
|
2009-06-29 15:33:01 +00:00
|
|
|
CMPZ, // ARM compare that sets only Z flag.
|
2007-01-19 07:51:42 +00:00
|
|
|
CMPFP, // ARM VFP compare instruction, sets FPSCR.
|
|
|
|
CMPFPw0, // ARM VFP compare against zero instruction, sets FPSCR.
|
|
|
|
FMSTAT, // ARM fmstat instruction.
|
|
|
|
CMOV, // ARM conditional move instructions.
|
|
|
|
CNEG, // ARM conditional negate instructions.
|
2009-05-13 22:32:43 +00:00
|
|
|
|
2007-01-19 07:51:42 +00:00
|
|
|
FTOSI, // FP to sint within a FP register.
|
|
|
|
FTOUI, // FP to uint within a FP register.
|
|
|
|
SITOF, // sint to FP within a FP register.
|
|
|
|
UITOF, // uint to FP within a FP register.
|
|
|
|
|
|
|
|
SRL_FLAG, // V,Flag = srl_flag X -> srl X, 1 + save carry out.
|
|
|
|
SRA_FLAG, // V,Flag = sra_flag X -> sra X, 1 + save carry out.
|
|
|
|
RRX, // V = RRX X, Flag -> srl X, 1 + shift in carry flag.
|
2009-05-13 22:32:43 +00:00
|
|
|
|
2009-11-09 00:11:35 +00:00
|
|
|
VMOVRRD, // double to two gprs.
|
|
|
|
VMOVDRR, // Two gprs to double.
|
2007-04-27 13:54:47 +00:00
|
|
|
|
2009-08-07 00:34:42 +00:00
|
|
|
EH_SJLJ_SETJMP, // SjLj exception handling setjmp.
|
|
|
|
EH_SJLJ_LONGJMP, // SjLj exception handling longjmp.
|
2009-05-12 23:59:14 +00:00
|
|
|
|
2009-06-22 23:27:02 +00:00
|
|
|
THREAD_POINTER,
|
|
|
|
|
2009-08-07 00:34:42 +00:00
|
|
|
DYN_ALLOC, // Dynamic allocation on the stack.
|
|
|
|
|
2009-12-10 00:11:09 +00:00
|
|
|
MEMBARRIER, // Memory barrier
|
|
|
|
SYNCBARRIER, // Memory sync barrier
|
|
|
|
|
2009-06-22 23:27:02 +00:00
|
|
|
VCEQ, // Vector compare equal.
|
|
|
|
VCGE, // Vector compare greater than or equal.
|
|
|
|
VCGEU, // Vector compare unsigned greater than or equal.
|
|
|
|
VCGT, // Vector compare greater than.
|
|
|
|
VCGTU, // Vector compare unsigned greater than.
|
|
|
|
VTST, // Vector test bits.
|
|
|
|
|
|
|
|
// Vector shift by immediate:
|
|
|
|
VSHL, // ...left
|
|
|
|
VSHRs, // ...right (signed)
|
|
|
|
VSHRu, // ...right (unsigned)
|
|
|
|
VSHLLs, // ...left long (signed)
|
|
|
|
VSHLLu, // ...left long (unsigned)
|
|
|
|
VSHLLi, // ...left long (with maximum shift count)
|
|
|
|
VSHRN, // ...right narrow
|
|
|
|
|
|
|
|
// Vector rounding shift by immediate:
|
|
|
|
VRSHRs, // ...right (signed)
|
|
|
|
VRSHRu, // ...right (unsigned)
|
|
|
|
VRSHRN, // ...right narrow
|
|
|
|
|
|
|
|
// Vector saturating shift by immediate:
|
|
|
|
VQSHLs, // ...left (signed)
|
|
|
|
VQSHLu, // ...left (unsigned)
|
|
|
|
VQSHLsu, // ...left (signed to unsigned)
|
|
|
|
VQSHRNs, // ...right narrow (signed)
|
|
|
|
VQSHRNu, // ...right narrow (unsigned)
|
|
|
|
VQSHRNsu, // ...right narrow (signed to unsigned)
|
|
|
|
|
|
|
|
// Vector saturating rounding shift by immediate:
|
|
|
|
VQRSHRNs, // ...right narrow (signed)
|
|
|
|
VQRSHRNu, // ...right narrow (unsigned)
|
|
|
|
VQRSHRNsu, // ...right narrow (signed to unsigned)
|
|
|
|
|
|
|
|
// Vector shift and insert:
|
|
|
|
VSLI, // ...left
|
|
|
|
VSRI, // ...right
|
|
|
|
|
|
|
|
// Vector get lane (VMOV scalar to ARM core register)
|
|
|
|
// (These are used for 8- and 16-bit element types only.)
|
|
|
|
VGETLANEu, // zero-extend vector extract element
|
|
|
|
VGETLANEs, // sign-extend vector extract element
|
|
|
|
|
2009-08-14 05:13:08 +00:00
|
|
|
// Vector duplicate:
|
|
|
|
VDUP,
|
2009-08-14 05:08:32 +00:00
|
|
|
VDUPLANE,
|
2009-08-04 00:36:16 +00:00
|
|
|
|
2009-08-12 22:31:50 +00:00
|
|
|
// Vector shuffles:
|
2009-08-19 17:03:43 +00:00
|
|
|
VEXT, // extract
|
2009-08-12 22:31:50 +00:00
|
|
|
VREV64, // reverse elements within 64-bit doublewords
|
|
|
|
VREV32, // reverse elements within 32-bit words
|
2009-08-21 12:41:24 +00:00
|
|
|
VREV16, // reverse elements within 16-bit halfwords
|
2009-08-21 20:54:19 +00:00
|
|
|
VZIP, // zip (interleave)
|
|
|
|
VUZP, // unzip (deinterleave)
|
2009-08-21 12:41:42 +00:00
|
|
|
VTRN // transpose
|
2007-01-19 07:51:42 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2009-06-22 23:27:02 +00:00
|
|
|
/// Define some predicates that are used for node matching.
|
|
|
|
namespace ARM {
|
|
|
|
/// getVMOVImm - If this is a build_vector of constants which can be
|
|
|
|
/// formed by using a VMOV instruction of the specified element size,
|
|
|
|
/// return the constant being splatted. The ByteSize field indicates the
|
|
|
|
/// number of bytes of each element [1248].
|
|
|
|
SDValue getVMOVImm(SDNode *N, unsigned ByteSize, SelectionDAG &DAG);
|
2009-10-28 01:44:26 +00:00
|
|
|
|
|
|
|
/// getVFPf32Imm / getVFPf64Imm - If the given fp immediate can be
|
|
|
|
/// materialized with a VMOV.f32 / VMOV.f64 (i.e. fconsts / fconstd)
|
|
|
|
/// instruction, returns its 8-bit integer representation. Otherwise,
|
|
|
|
/// returns -1.
|
|
|
|
int getVFPf32Imm(const APFloat &FPImm);
|
|
|
|
int getVFPf64Imm(const APFloat &FPImm);
|
2009-06-22 23:27:02 +00:00
|
|
|
}
|
|
|
|
|
2009-05-20 16:30:25 +00:00
|
|
|
//===--------------------------------------------------------------------===//
|
2007-03-20 00:30:56 +00:00
|
|
|
// ARMTargetLowering - ARM Implementation of the TargetLowering interface
|
2009-05-13 22:32:43 +00:00
|
|
|
|
2007-01-19 07:51:42 +00:00
|
|
|
class ARMTargetLowering : public TargetLowering {
|
|
|
|
int VarArgsFrameIndex; // FrameIndex for start of varargs area.
|
|
|
|
public:
|
2007-08-02 21:21:54 +00:00
|
|
|
explicit ARMTargetLowering(TargetMachine &TM);
|
2007-01-19 07:51:42 +00:00
|
|
|
|
2008-07-27 21:46:04 +00:00
|
|
|
virtual SDValue LowerOperation(SDValue Op, SelectionDAG &DAG);
|
2008-12-01 11:39:25 +00:00
|
|
|
|
|
|
|
/// ReplaceNodeResults - Replace the results of node with an illegal result
|
|
|
|
/// type with new values built out of custom code.
|
|
|
|
///
|
|
|
|
virtual void ReplaceNodeResults(SDNode *N, SmallVectorImpl<SDValue>&Results,
|
|
|
|
SelectionDAG &DAG);
|
|
|
|
|
2008-07-27 21:46:04 +00:00
|
|
|
virtual SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const;
|
2009-05-13 22:32:43 +00:00
|
|
|
|
2007-01-19 07:51:42 +00:00
|
|
|
virtual const char *getTargetNodeName(unsigned Opcode) const;
|
|
|
|
|
2008-01-30 18:18:23 +00:00
|
|
|
virtual MachineBasicBlock *EmitInstrWithCustomInserter(MachineInstr *MI,
|
2009-09-18 21:02:19 +00:00
|
|
|
MachineBasicBlock *MBB,
|
|
|
|
DenseMap<MachineBasicBlock*, MachineBasicBlock*>*) const;
|
2007-01-19 07:51:42 +00:00
|
|
|
|
2009-08-15 21:21:19 +00:00
|
|
|
/// allowsUnalignedMemoryAccesses - Returns true if the target allows
|
|
|
|
/// unaligned memory accesses. of the specified type.
|
|
|
|
/// FIXME: Add getOptimalMemOpType to implement memcpy with NEON?
|
|
|
|
virtual bool allowsUnalignedMemoryAccesses(EVT VT) const;
|
|
|
|
|
2007-03-30 23:15:24 +00:00
|
|
|
/// isLegalAddressingMode - Return true if the addressing mode represented
|
|
|
|
/// by AM is legal for this target, for a load/store of the specified type.
|
|
|
|
virtual bool isLegalAddressingMode(const AddrMode &AM, const Type *Ty)const;
|
2009-08-14 20:09:37 +00:00
|
|
|
bool isLegalT2ScaledAddressingMode(const AddrMode &AM, EVT VT) const;
|
2009-05-13 22:32:43 +00:00
|
|
|
|
2009-11-11 19:05:52 +00:00
|
|
|
/// isLegalICmpImmediate - Return true if the specified immediate is legal
|
|
|
|
/// icmp immediate, that is the target has icmp instructions which can compare
|
|
|
|
/// a register against the immediate without having to materialize the
|
|
|
|
/// immediate into a register.
|
2009-11-12 07:13:11 +00:00
|
|
|
virtual bool isLegalICmpImmediate(int64_t Imm) const;
|
2009-11-11 19:05:52 +00:00
|
|
|
|
2007-01-19 07:51:42 +00:00
|
|
|
/// getPreIndexedAddressParts - returns true by value, base pointer and
|
|
|
|
/// offset pointer and addressing mode by reference if the node's address
|
|
|
|
/// can be legally represented as pre-indexed load / store address.
|
2008-07-27 21:46:04 +00:00
|
|
|
virtual bool getPreIndexedAddressParts(SDNode *N, SDValue &Base,
|
|
|
|
SDValue &Offset,
|
2007-01-19 07:51:42 +00:00
|
|
|
ISD::MemIndexedMode &AM,
|
2009-01-15 16:29:45 +00:00
|
|
|
SelectionDAG &DAG) const;
|
2007-01-19 07:51:42 +00:00
|
|
|
|
|
|
|
/// getPostIndexedAddressParts - returns true by value, base pointer and
|
|
|
|
/// offset pointer and addressing mode by reference if this node can be
|
|
|
|
/// combined with a load / store to form a post-indexed load / store.
|
|
|
|
virtual bool getPostIndexedAddressParts(SDNode *N, SDNode *Op,
|
2008-07-27 21:46:04 +00:00
|
|
|
SDValue &Base, SDValue &Offset,
|
2007-01-19 07:51:42 +00:00
|
|
|
ISD::MemIndexedMode &AM,
|
2009-01-15 16:29:45 +00:00
|
|
|
SelectionDAG &DAG) const;
|
2007-01-19 07:51:42 +00:00
|
|
|
|
2008-07-27 21:46:04 +00:00
|
|
|
virtual void computeMaskedBitsForTargetNode(const SDValue Op,
|
2008-02-13 22:28:48 +00:00
|
|
|
const APInt &Mask,
|
2009-05-13 22:32:43 +00:00
|
|
|
APInt &KnownZero,
|
2008-02-13 00:35:47 +00:00
|
|
|
APInt &KnownOne,
|
2007-06-22 14:59:07 +00:00
|
|
|
const SelectionDAG &DAG,
|
2007-01-19 07:51:42 +00:00
|
|
|
unsigned Depth) const;
|
2009-08-15 21:21:19 +00:00
|
|
|
|
|
|
|
|
2007-03-25 02:14:49 +00:00
|
|
|
ConstraintType getConstraintType(const std::string &Constraint) const;
|
2009-05-13 22:32:43 +00:00
|
|
|
std::pair<unsigned, const TargetRegisterClass*>
|
2007-01-19 07:51:42 +00:00
|
|
|
getRegForInlineAsmConstraint(const std::string &Constraint,
|
2009-08-10 22:56:29 +00:00
|
|
|
EVT VT) const;
|
2007-01-19 07:51:42 +00:00
|
|
|
std::vector<unsigned>
|
|
|
|
getRegClassForInlineAsmConstraint(const std::string &Constraint,
|
2009-08-10 22:56:29 +00:00
|
|
|
EVT VT) const;
|
2007-11-05 23:12:20 +00:00
|
|
|
|
2009-04-01 17:58:54 +00:00
|
|
|
/// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
|
|
|
|
/// vector. If it is invalid, don't add anything to Ops. If hasMemory is
|
|
|
|
/// true it means one of the asm constraint of the inline asm instruction
|
|
|
|
/// being processed is 'm'.
|
|
|
|
virtual void LowerAsmOperandForConstraint(SDValue Op,
|
|
|
|
char ConstraintLetter,
|
|
|
|
bool hasMemory,
|
|
|
|
std::vector<SDValue> &Ops,
|
|
|
|
SelectionDAG &DAG) const;
|
2009-05-13 22:32:43 +00:00
|
|
|
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
virtual const ARMSubtarget* getSubtarget() {
|
|
|
|
return Subtarget;
|
2007-11-05 23:12:20 +00:00
|
|
|
}
|
|
|
|
|
2009-07-01 18:50:55 +00:00
|
|
|
/// getFunctionAlignment - Return the Log2 alignment of this function.
|
2009-06-30 22:38:32 +00:00
|
|
|
virtual unsigned getFunctionAlignment(const Function *F) const;
|
|
|
|
|
2009-08-21 12:40:07 +00:00
|
|
|
bool isShuffleMaskLegal(const SmallVectorImpl<int> &M, EVT VT) const;
|
2009-09-23 19:04:09 +00:00
|
|
|
bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const;
|
2009-10-28 01:44:26 +00:00
|
|
|
|
|
|
|
/// isFPImmLegal - Returns true if the target can instruction select the
|
|
|
|
/// specified FP immediate natively. If false, the legalizer will
|
|
|
|
/// materialize the FP immediate as a load from a constant pool.
|
|
|
|
virtual bool isFPImmLegal(const APFloat &Imm, EVT VT) const;
|
|
|
|
|
2007-01-19 07:51:42 +00:00
|
|
|
private:
|
|
|
|
/// Subtarget - Keep a pointer to the ARMSubtarget around so that we can
|
|
|
|
/// make the right decision when generating code for different targets.
|
|
|
|
const ARMSubtarget *Subtarget;
|
|
|
|
|
2009-07-13 18:11:36 +00:00
|
|
|
/// ARMPCLabelIndex - Keep track of the number of ARM PC labels created.
|
2007-01-19 07:51:42 +00:00
|
|
|
///
|
|
|
|
unsigned ARMPCLabelIndex;
|
|
|
|
|
2009-08-10 22:56:29 +00:00
|
|
|
void addTypeForNEON(EVT VT, EVT PromotedLdStVT, EVT PromotedBitwiseVT);
|
|
|
|
void addDRTypeForNEON(EVT VT);
|
|
|
|
void addQRTypeForNEON(EVT VT);
|
2009-06-22 23:27:02 +00:00
|
|
|
|
|
|
|
typedef SmallVector<std::pair<unsigned, SDValue>, 8> RegsToPassVector;
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78142 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-05 01:29:28 +00:00
|
|
|
void PassF64ArgInRegs(DebugLoc dl, SelectionDAG &DAG,
|
2009-06-22 23:27:02 +00:00
|
|
|
SDValue Chain, SDValue &Arg,
|
|
|
|
RegsToPassVector &RegsToPass,
|
|
|
|
CCValAssign &VA, CCValAssign &NextVA,
|
|
|
|
SDValue &StackPtr,
|
|
|
|
SmallVector<SDValue, 8> &MemOpChains,
|
|
|
|
ISD::ArgFlagsTy Flags);
|
|
|
|
SDValue GetF64FormalArgument(CCValAssign &VA, CCValAssign &NextVA,
|
|
|
|
SDValue &Root, SelectionDAG &DAG, DebugLoc dl);
|
|
|
|
|
2009-09-02 08:44:58 +00:00
|
|
|
CCAssignFn *CCAssignFnForNode(CallingConv::ID CC, bool Return, bool isVarArg) const;
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78142 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-05 01:29:28 +00:00
|
|
|
SDValue LowerMemOpCallTo(SDValue Chain, SDValue StackPtr, SDValue Arg,
|
|
|
|
DebugLoc dl, SelectionDAG &DAG,
|
|
|
|
const CCValAssign &VA,
|
|
|
|
ISD::ArgFlagsTy Flags);
|
2009-08-04 00:36:16 +00:00
|
|
|
SDValue LowerINTRINSIC_W_CHAIN(SDValue Op, SelectionDAG &DAG);
|
2009-05-12 23:59:14 +00:00
|
|
|
SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG);
|
2009-10-30 05:45:42 +00:00
|
|
|
SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG);
|
2008-07-27 21:46:04 +00:00
|
|
|
SDValue LowerGlobalAddressDarwin(SDValue Op, SelectionDAG &DAG);
|
|
|
|
SDValue LowerGlobalAddressELF(SDValue Op, SelectionDAG &DAG);
|
|
|
|
SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG);
|
|
|
|
SDValue LowerToTLSGeneralDynamicModel(GlobalAddressSDNode *GA,
|
2007-04-27 13:54:47 +00:00
|
|
|
SelectionDAG &DAG);
|
2008-07-27 21:46:04 +00:00
|
|
|
SDValue LowerToTLSExecModels(GlobalAddressSDNode *GA,
|
2007-10-22 22:11:27 +00:00
|
|
|
SelectionDAG &DAG);
|
2008-07-27 21:46:04 +00:00
|
|
|
SDValue LowerGLOBAL_OFFSET_TABLE(SDValue Op, SelectionDAG &DAG);
|
|
|
|
SDValue LowerBR_JT(SDValue Op, SelectionDAG &DAG);
|
2009-11-12 07:13:11 +00:00
|
|
|
SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG);
|
|
|
|
SDValue LowerBR_CC(SDValue Op, SelectionDAG &DAG);
|
2009-05-12 23:59:14 +00:00
|
|
|
SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG);
|
2009-08-07 00:34:42 +00:00
|
|
|
SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG);
|
2009-11-12 07:13:11 +00:00
|
|
|
SDValue LowerShiftRightParts(SDValue Op, SelectionDAG &DAG);
|
|
|
|
SDValue LowerShiftLeftParts(SDValue Op, SelectionDAG &DAG);
|
2008-07-27 21:46:04 +00:00
|
|
|
|
2009-02-03 22:26:09 +00:00
|
|
|
SDValue EmitTargetCodeForMemcpy(SelectionDAG &DAG, DebugLoc dl,
|
2008-07-27 21:46:04 +00:00
|
|
|
SDValue Chain,
|
|
|
|
SDValue Dst, SDValue Src,
|
|
|
|
SDValue Size, unsigned Align,
|
Drop ISD::MEMSET, ISD::MEMMOVE, and ISD::MEMCPY, which are not Legal
on any current target and aren't optimized in DAGCombiner. Instead
of using intermediate nodes, expand the operations, choosing between
simple loads/stores, target-specific code, and library calls,
immediately.
Previously, the code to emit optimized code for these operations
was only used at initial SelectionDAG construction time; now it is
used at all times. This fixes some cases where rep;movs was being
used for small copies where simple loads/stores would be better.
This also cleans up code that checks for alignments less than 4;
let the targets make that decision instead of doing it in
target-independent code. This allows x86 to use rep;movs in
low-alignment cases.
Also, this fixes a bug that resulted in the use of rep;stos for
memsets of 0 with non-constant memory size when the alignment was
at least 4. It's better to use the library in this case, which
can be significantly faster when the size is large.
This also preserves more SourceValue information when memory
intrinsics are lowered into simple loads/stores.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49572 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-12 04:36:06 +00:00
|
|
|
bool AlwaysInline,
|
2008-04-28 17:15:20 +00:00
|
|
|
const Value *DstSV, uint64_t DstSVOff,
|
|
|
|
const Value *SrcSV, uint64_t SrcSVOff);
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78142 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-05 01:29:28 +00:00
|
|
|
SDValue LowerCallResult(SDValue Chain, SDValue InFlag,
|
2009-09-02 08:44:58 +00:00
|
|
|
CallingConv::ID CallConv, bool isVarArg,
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78142 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-05 01:29:28 +00:00
|
|
|
const SmallVectorImpl<ISD::InputArg> &Ins,
|
|
|
|
DebugLoc dl, SelectionDAG &DAG,
|
|
|
|
SmallVectorImpl<SDValue> &InVals);
|
|
|
|
|
|
|
|
virtual SDValue
|
|
|
|
LowerFormalArguments(SDValue Chain,
|
2009-09-02 08:44:58 +00:00
|
|
|
CallingConv::ID CallConv, bool isVarArg,
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78142 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-05 01:29:28 +00:00
|
|
|
const SmallVectorImpl<ISD::InputArg> &Ins,
|
|
|
|
DebugLoc dl, SelectionDAG &DAG,
|
|
|
|
SmallVectorImpl<SDValue> &InVals);
|
|
|
|
|
|
|
|
virtual SDValue
|
|
|
|
LowerCall(SDValue Chain, SDValue Callee,
|
2009-09-02 08:44:58 +00:00
|
|
|
CallingConv::ID CallConv, bool isVarArg,
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78142 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-05 01:29:28 +00:00
|
|
|
bool isTailCall,
|
|
|
|
const SmallVectorImpl<ISD::OutputArg> &Outs,
|
|
|
|
const SmallVectorImpl<ISD::InputArg> &Ins,
|
|
|
|
DebugLoc dl, SelectionDAG &DAG,
|
|
|
|
SmallVectorImpl<SDValue> &InVals);
|
|
|
|
|
|
|
|
virtual SDValue
|
|
|
|
LowerReturn(SDValue Chain,
|
2009-09-02 08:44:58 +00:00
|
|
|
CallingConv::ID CallConv, bool isVarArg,
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78142 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-05 01:29:28 +00:00
|
|
|
const SmallVectorImpl<ISD::OutputArg> &Outs,
|
|
|
|
DebugLoc dl, SelectionDAG &DAG);
|
2009-11-12 07:13:11 +00:00
|
|
|
|
|
|
|
SDValue getARMCmp(SDValue LHS, SDValue RHS, ISD::CondCode CC,
|
|
|
|
SDValue &ARMCC, SelectionDAG &DAG, DebugLoc dl);
|
2009-12-11 01:42:04 +00:00
|
|
|
|
|
|
|
MachineBasicBlock *EmitAtomicCmpSwap(unsigned Size, MachineInstr *MI,
|
|
|
|
MachineBasicBlock *BB) const;
|
|
|
|
|
2007-01-19 07:51:42 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // ARMISELLOWERING_H
|