2012-02-18 12:03:15 +00:00
|
|
|
//===-- HexagonISelLowering.h - Hexagon DAG Lowering Interface --*- C++ -*-===//
|
2011-12-12 21:14:40 +00:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file defines the interfaces that Hexagon uses to lower LLVM code into a
|
|
|
|
// selection DAG.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-08-13 16:26:38 +00:00
|
|
|
#ifndef LLVM_LIB_TARGET_HEXAGON_HEXAGONISELLOWERING_H
|
|
|
|
#define LLVM_LIB_TARGET_HEXAGON_HEXAGONISELLOWERING_H
|
2011-12-12 21:14:40 +00:00
|
|
|
|
2012-03-17 18:46:09 +00:00
|
|
|
#include "Hexagon.h"
|
2011-12-12 21:14:40 +00:00
|
|
|
#include "llvm/CodeGen/CallingConvLower.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/CallingConv.h"
|
2012-12-04 07:12:27 +00:00
|
|
|
#include "llvm/Target/TargetLowering.h"
|
2011-12-12 21:14:40 +00:00
|
|
|
|
|
|
|
namespace llvm {
|
2014-12-08 21:19:18 +00:00
|
|
|
|
|
|
|
// Return true when the given node fits in a positive half word.
|
|
|
|
bool isPositiveHalfWord(SDNode *N);
|
|
|
|
|
2011-12-12 21:14:40 +00:00
|
|
|
namespace HexagonISD {
|
|
|
|
enum {
|
|
|
|
FIRST_NUMBER = ISD::BUILTIN_OP_END,
|
|
|
|
|
|
|
|
CONST32,
|
|
|
|
CONST32_GP, // For marking data present in GP.
|
2013-03-07 19:10:28 +00:00
|
|
|
CONST32_Int_Real,
|
2012-05-10 20:20:25 +00:00
|
|
|
FCONST32,
|
2011-12-12 21:14:40 +00:00
|
|
|
SETCC,
|
|
|
|
ADJDYNALLOC,
|
|
|
|
ARGEXTEND,
|
|
|
|
|
|
|
|
CMPICC, // Compare two GPR operands, set icc.
|
|
|
|
CMPFCC, // Compare two FP operands, set fcc.
|
|
|
|
BRICC, // Branch to dest on icc condition
|
|
|
|
BRFCC, // Branch to dest on fcc condition
|
|
|
|
SELECT_ICC, // Select between two values using the current ICC flags.
|
|
|
|
SELECT_FCC, // Select between two values using the current FCC flags.
|
|
|
|
|
|
|
|
Hi, Lo, // Hi/Lo operations, typically on a global address.
|
|
|
|
|
|
|
|
FTOI, // FP to Int within a FP register.
|
|
|
|
ITOF, // Int to FP within a FP register.
|
|
|
|
|
2015-01-16 17:05:27 +00:00
|
|
|
CALLv3, // A V3+ call instruction.
|
|
|
|
CALLv3nr, // A V3+ call instruction that doesn't return.
|
|
|
|
CALLR,
|
|
|
|
|
2011-12-12 21:14:40 +00:00
|
|
|
RET_FLAG, // Return with a flag operand.
|
|
|
|
BR_JT, // Jump table.
|
2015-01-07 20:07:28 +00:00
|
|
|
BARRIER, // Memory barrier
|
|
|
|
POPCOUNT,
|
2014-12-05 18:24:06 +00:00
|
|
|
COMBINE,
|
2011-12-12 21:14:40 +00:00
|
|
|
WrapperJT,
|
2012-05-10 20:20:25 +00:00
|
|
|
WrapperCP,
|
2012-12-04 18:05:01 +00:00
|
|
|
WrapperCombineII,
|
|
|
|
WrapperCombineRR,
|
2013-02-04 15:52:56 +00:00
|
|
|
WrapperCombineRI_V4,
|
|
|
|
WrapperCombineIR_V4,
|
2012-12-04 18:05:01 +00:00
|
|
|
WrapperPackhl,
|
|
|
|
WrapperSplatB,
|
|
|
|
WrapperSplatH,
|
|
|
|
WrapperShuffEB,
|
|
|
|
WrapperShuffEH,
|
|
|
|
WrapperShuffOB,
|
|
|
|
WrapperShuffOH,
|
2013-05-01 21:37:34 +00:00
|
|
|
TC_RETURN,
|
2015-01-06 19:03:20 +00:00
|
|
|
EH_RETURN,
|
|
|
|
DCFETCH
|
2011-12-12 21:14:40 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2015-02-02 22:11:36 +00:00
|
|
|
class HexagonSubtarget;
|
|
|
|
|
2011-12-12 21:14:40 +00:00
|
|
|
class HexagonTargetLowering : public TargetLowering {
|
|
|
|
int VarArgsFrameOffset; // Frame offset to start of varargs area.
|
|
|
|
|
|
|
|
bool CanReturnSmallStruct(const Function* CalleeFn,
|
|
|
|
unsigned& RetSize) const;
|
|
|
|
|
|
|
|
public:
|
2015-02-02 22:11:36 +00:00
|
|
|
const HexagonSubtarget *Subtarget;
|
|
|
|
explicit HexagonTargetLowering(const TargetMachine &TM,
|
|
|
|
const HexagonSubtarget &Subtarget);
|
2011-12-12 21:14:40 +00:00
|
|
|
|
|
|
|
/// IsEligibleForTailCallOptimization - Check whether the call is eligible
|
|
|
|
/// for tail call optimization. Targets which want to do tail call
|
|
|
|
/// optimization should implement this function.
|
|
|
|
bool
|
|
|
|
IsEligibleForTailCallOptimization(SDValue Callee,
|
|
|
|
CallingConv::ID CalleeCC,
|
|
|
|
bool isVarArg,
|
|
|
|
bool isCalleeStructRet,
|
|
|
|
bool isCallerStructRet,
|
|
|
|
const
|
|
|
|
SmallVectorImpl<ISD::OutputArg> &Outs,
|
|
|
|
const SmallVectorImpl<SDValue> &OutVals,
|
|
|
|
const SmallVectorImpl<ISD::InputArg> &Ins,
|
|
|
|
SelectionDAG& DAG) const;
|
|
|
|
|
2014-04-29 07:58:16 +00:00
|
|
|
bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
|
|
|
|
bool isTruncateFree(EVT VT1, EVT VT2) const override;
|
2011-12-12 21:14:40 +00:00
|
|
|
|
2014-04-29 07:58:16 +00:00
|
|
|
bool allowTruncateForTailCall(Type *Ty1, Type *Ty2) const override;
|
Refactor isInTailCallPosition handling
This change came about primarily because of two issues in the existing code.
Niether of:
define i64 @test1(i64 %val) {
%in = trunc i64 %val to i32
tail call i32 @ret32(i32 returned %in)
ret i64 %val
}
define i64 @test2(i64 %val) {
tail call i32 @ret32(i32 returned undef)
ret i32 42
}
should be tail calls, and the function sameNoopInput is responsible. The main
problem is that it is completely symmetric in the "tail call" and "ret" value,
but in reality different things are allowed on each side.
For these cases:
1. Any truncation should lead to a larger value being generated by "tail call"
than needed by "ret".
2. Undef should only be allowed as a source for ret, not as a result of the
call.
Along the way I noticed that a mismatch between what this function treats as a
valid truncation and what the backends see can lead to invalid calls as well
(see x86-32 test case).
This patch refactors the code so that instead of being based primarily on
values which it recurses into when necessary, it starts by inspecting the type
and considers each fundamental slot that the backend will see in turn. For
example, given a pathological function that returned {{}, {{}, i32, {}}, i32}
we would consider each "real" i32 in turn, and ask if it passes through
unchanged. This is much closer to what the backend sees as a result of
ComputeValueVTs.
Aside from the bug fixes, this eliminates the recursion that's going on and, I
believe, makes the bulk of the code significantly easier to understand. The
trade-off is the nasty iterators needed to find the real types inside a
returned value.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@187787 91177308-0d34-0410-b5e6-96231b3b80d8
2013-08-06 09:12:35 +00:00
|
|
|
|
2014-04-29 07:58:16 +00:00
|
|
|
SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
|
2011-12-12 21:14:40 +00:00
|
|
|
|
2014-04-29 07:58:16 +00:00
|
|
|
const char *getTargetNodeName(unsigned Opcode) const override;
|
2011-12-12 21:14:40 +00:00
|
|
|
SDValue LowerBR_JT(SDValue Op, SelectionDAG &DAG) const;
|
|
|
|
SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const;
|
|
|
|
SDValue LowerINLINEASM(SDValue Op, SelectionDAG &DAG) const;
|
|
|
|
SDValue LowerEH_LABEL(SDValue Op, SelectionDAG &DAG) const;
|
2013-05-01 21:37:34 +00:00
|
|
|
SDValue LowerEH_RETURN(SDValue Op, SelectionDAG &DAG) const;
|
2011-12-12 21:14:40 +00:00
|
|
|
SDValue LowerFormalArguments(SDValue Chain,
|
|
|
|
CallingConv::ID CallConv, bool isVarArg,
|
|
|
|
const SmallVectorImpl<ISD::InputArg> &Ins,
|
2013-05-25 02:42:55 +00:00
|
|
|
SDLoc dl, SelectionDAG &DAG,
|
2014-04-29 07:58:16 +00:00
|
|
|
SmallVectorImpl<SDValue> &InVals) const override;
|
2011-12-12 21:14:40 +00:00
|
|
|
SDValue LowerGLOBALADDRESS(SDValue Op, SelectionDAG &DAG) const;
|
2013-03-07 19:10:28 +00:00
|
|
|
SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
|
2011-12-12 21:14:40 +00:00
|
|
|
|
2012-05-25 16:35:28 +00:00
|
|
|
SDValue LowerCall(TargetLowering::CallLoweringInfo &CLI,
|
2014-04-29 07:58:16 +00:00
|
|
|
SmallVectorImpl<SDValue> &InVals) const override;
|
2011-12-12 21:14:40 +00:00
|
|
|
|
|
|
|
SDValue LowerCallResult(SDValue Chain, SDValue InFlag,
|
|
|
|
CallingConv::ID CallConv, bool isVarArg,
|
|
|
|
const SmallVectorImpl<ISD::InputArg> &Ins,
|
2013-05-25 02:42:55 +00:00
|
|
|
SDLoc dl, SelectionDAG &DAG,
|
2011-12-12 21:14:40 +00:00
|
|
|
SmallVectorImpl<SDValue> &InVals,
|
|
|
|
const SmallVectorImpl<SDValue> &OutVals,
|
|
|
|
SDValue Callee) const;
|
|
|
|
|
|
|
|
SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
|
|
|
|
SDValue LowerATOMIC_FENCE(SDValue Op, SelectionDAG& DAG) const;
|
|
|
|
SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
|
|
|
|
|
|
|
|
SDValue LowerReturn(SDValue Chain,
|
|
|
|
CallingConv::ID CallConv, bool isVarArg,
|
|
|
|
const SmallVectorImpl<ISD::OutputArg> &Outs,
|
|
|
|
const SmallVectorImpl<SDValue> &OutVals,
|
2014-04-29 07:58:16 +00:00
|
|
|
SDLoc dl, SelectionDAG &DAG) const override;
|
2011-12-12 21:14:40 +00:00
|
|
|
|
2014-04-29 07:58:16 +00:00
|
|
|
MachineBasicBlock *
|
|
|
|
EmitInstrWithCustomInserter(MachineInstr *MI,
|
|
|
|
MachineBasicBlock *BB) const override;
|
2011-12-12 21:14:40 +00:00
|
|
|
|
|
|
|
SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
|
2012-05-10 20:20:25 +00:00
|
|
|
SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
|
2014-04-29 07:58:16 +00:00
|
|
|
EVT getSetCCResultType(LLVMContext &C, EVT VT) const override {
|
2013-11-13 01:57:54 +00:00
|
|
|
if (!VT.isVector())
|
|
|
|
return MVT::i1;
|
|
|
|
else
|
|
|
|
return EVT::getVectorVT(C, MVT::i1, VT.getVectorNumElements());
|
2011-12-12 21:14:40 +00:00
|
|
|
}
|
|
|
|
|
2014-04-29 07:58:16 +00:00
|
|
|
bool getPostIndexedAddressParts(SDNode *N, SDNode *Op,
|
|
|
|
SDValue &Base, SDValue &Offset,
|
|
|
|
ISD::MemIndexedMode &AM,
|
|
|
|
SelectionDAG &DAG) const override;
|
2011-12-12 21:14:40 +00:00
|
|
|
|
|
|
|
std::pair<unsigned, const TargetRegisterClass*>
|
|
|
|
getRegForInlineAsmConstraint(const std::string &Constraint,
|
2014-04-29 07:58:16 +00:00
|
|
|
MVT VT) const override;
|
2011-12-12 21:14:40 +00:00
|
|
|
|
|
|
|
// Intrinsics
|
2014-04-29 07:58:16 +00:00
|
|
|
SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const;
|
2011-12-12 21:14:40 +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.
|
|
|
|
/// The type may be VoidTy, in which case only return true if the addressing
|
|
|
|
/// mode is legal for a load/store of any legal type.
|
|
|
|
/// TODO: Handle pre/postinc as well.
|
2014-04-29 07:58:16 +00:00
|
|
|
bool isLegalAddressingMode(const AddrMode &AM, Type *Ty) const override;
|
|
|
|
bool isFPImmLegal(const APFloat &Imm, EVT VT) const override;
|
2011-12-12 21:14:40 +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.
|
2014-04-29 07:58:16 +00:00
|
|
|
bool isLegalICmpImmediate(int64_t Imm) const override;
|
2011-12-12 21:14:40 +00:00
|
|
|
};
|
|
|
|
} // end namespace llvm
|
|
|
|
|
|
|
|
#endif // Hexagon_ISELLOWERING_H
|