2005-09-03 02:46:02 +08:00
|
|
|
//===-- AlphaISelLowering.cpp - Alpha DAG Lowering Implementation ---------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-30 04:36:04 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-09-03 02:46:02 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements the AlphaISelLowering class.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "AlphaISelLowering.h"
|
|
|
|
#include "AlphaTargetMachine.h"
|
|
|
|
#include "llvm/CodeGen/MachineFrameInfo.h"
|
|
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
|
|
#include "llvm/CodeGen/MachineInstrBuilder.h"
|
2007-12-31 12:13:23 +08:00
|
|
|
#include "llvm/CodeGen/MachineRegisterInfo.h"
|
2005-09-03 02:46:02 +08:00
|
|
|
#include "llvm/CodeGen/SelectionDAG.h"
|
2007-12-31 12:13:23 +08:00
|
|
|
#include "llvm/CodeGen/MachineRegisterInfo.h"
|
2005-09-03 02:46:02 +08:00
|
|
|
#include "llvm/Constants.h"
|
|
|
|
#include "llvm/Function.h"
|
2006-01-24 04:59:50 +08:00
|
|
|
#include "llvm/Module.h"
|
2008-10-07 10:10:26 +08:00
|
|
|
#include "llvm/Intrinsics.h"
|
2005-09-03 02:46:02 +08:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
/// AddLiveIn - This helper function adds the specified physical register to the
|
|
|
|
/// MachineFunction as a live in value. It also creates a corresponding virtual
|
|
|
|
/// register for it.
|
|
|
|
static unsigned AddLiveIn(MachineFunction &MF, unsigned PReg,
|
|
|
|
TargetRegisterClass *RC) {
|
|
|
|
assert(RC->contains(PReg) && "Not the correct regclass!");
|
2007-12-31 12:13:23 +08:00
|
|
|
unsigned VReg = MF.getRegInfo().createVirtualRegister(RC);
|
|
|
|
MF.getRegInfo().addLiveIn(PReg, VReg);
|
2005-09-03 02:46:02 +08:00
|
|
|
return VReg;
|
|
|
|
}
|
|
|
|
|
|
|
|
AlphaTargetLowering::AlphaTargetLowering(TargetMachine &TM) : TargetLowering(TM) {
|
|
|
|
// Set up the TargetLowering object.
|
2009-06-15 07:30:43 +08:00
|
|
|
//I am having problems with shr n i8 1
|
2005-09-03 02:46:02 +08:00
|
|
|
setShiftAmountType(MVT::i64);
|
2008-11-23 23:47:28 +08:00
|
|
|
setBooleanContents(ZeroOrOneBooleanContent);
|
2005-09-03 02:46:02 +08:00
|
|
|
|
2006-10-07 06:46:51 +08:00
|
|
|
setUsesGlobalOffsetTable(true);
|
|
|
|
|
2005-09-03 02:46:02 +08:00
|
|
|
addRegisterClass(MVT::i64, Alpha::GPRCRegisterClass);
|
2005-11-10 03:17:08 +08:00
|
|
|
addRegisterClass(MVT::f64, Alpha::F8RCRegisterClass);
|
|
|
|
addRegisterClass(MVT::f32, Alpha::F4RCRegisterClass);
|
2008-10-07 10:10:26 +08:00
|
|
|
|
|
|
|
// We want to custom lower some of our intrinsics.
|
|
|
|
setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
|
|
|
|
|
2008-10-15 05:26:46 +08:00
|
|
|
setLoadExtAction(ISD::EXTLOAD, MVT::i1, Promote);
|
|
|
|
setLoadExtAction(ISD::EXTLOAD, MVT::f32, Expand);
|
2005-09-03 02:46:02 +08:00
|
|
|
|
2008-10-15 05:26:46 +08:00
|
|
|
setLoadExtAction(ISD::ZEXTLOAD, MVT::i1, Promote);
|
|
|
|
setLoadExtAction(ISD::ZEXTLOAD, MVT::i32, Expand);
|
2005-09-03 02:46:02 +08:00
|
|
|
|
2008-10-15 05:26:46 +08:00
|
|
|
setLoadExtAction(ISD::SEXTLOAD, MVT::i1, Promote);
|
|
|
|
setLoadExtAction(ISD::SEXTLOAD, MVT::i8, Expand);
|
|
|
|
setLoadExtAction(ISD::SEXTLOAD, MVT::i16, Expand);
|
2006-10-14 05:14:26 +08:00
|
|
|
|
2006-10-30 16:02:39 +08:00
|
|
|
// setOperationAction(ISD::BRIND, MVT::Other, Expand);
|
|
|
|
setOperationAction(ISD::BR_JT, MVT::Other, Expand);
|
2006-10-04 08:56:09 +08:00
|
|
|
setOperationAction(ISD::BR_CC, MVT::Other, Expand);
|
2006-10-14 05:14:26 +08:00
|
|
|
setOperationAction(ISD::SELECT_CC, MVT::Other, Expand);
|
2005-10-07 00:54:29 +08:00
|
|
|
|
2006-06-28 07:19:14 +08:00
|
|
|
setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand);
|
|
|
|
|
2005-09-29 06:29:17 +08:00
|
|
|
setOperationAction(ISD::FREM, MVT::f32, Expand);
|
|
|
|
setOperationAction(ISD::FREM, MVT::f64, Expand);
|
2005-09-03 02:46:02 +08:00
|
|
|
|
|
|
|
setOperationAction(ISD::UINT_TO_FP, MVT::i64, Expand);
|
2005-11-30 15:19:56 +08:00
|
|
|
setOperationAction(ISD::SINT_TO_FP, MVT::i64, Custom);
|
2005-12-01 00:10:29 +08:00
|
|
|
setOperationAction(ISD::FP_TO_UINT, MVT::i64, Expand);
|
|
|
|
setOperationAction(ISD::FP_TO_SINT, MVT::i64, Custom);
|
|
|
|
|
2005-09-30 06:54:56 +08:00
|
|
|
if (!TM.getSubtarget<AlphaSubtarget>().hasCT()) {
|
2005-09-03 02:46:02 +08:00
|
|
|
setOperationAction(ISD::CTPOP , MVT::i64 , Expand);
|
|
|
|
setOperationAction(ISD::CTTZ , MVT::i64 , Expand);
|
|
|
|
setOperationAction(ISD::CTLZ , MVT::i64 , Expand);
|
|
|
|
}
|
2006-01-14 11:14:10 +08:00
|
|
|
setOperationAction(ISD::BSWAP , MVT::i64, Expand);
|
2006-01-12 05:21:00 +08:00
|
|
|
setOperationAction(ISD::ROTL , MVT::i64, Expand);
|
|
|
|
setOperationAction(ISD::ROTR , MVT::i64, Expand);
|
2005-09-03 02:46:02 +08:00
|
|
|
|
2005-12-25 09:34:27 +08:00
|
|
|
setOperationAction(ISD::SREM , MVT::i64, Custom);
|
|
|
|
setOperationAction(ISD::UREM , MVT::i64, Custom);
|
|
|
|
setOperationAction(ISD::SDIV , MVT::i64, Custom);
|
|
|
|
setOperationAction(ISD::UDIV , MVT::i64, Custom);
|
2006-04-03 11:18:59 +08:00
|
|
|
|
2008-10-07 10:10:26 +08:00
|
|
|
setOperationAction(ISD::ADDC , MVT::i64, Expand);
|
|
|
|
setOperationAction(ISD::ADDE , MVT::i64, Expand);
|
|
|
|
setOperationAction(ISD::SUBC , MVT::i64, Expand);
|
|
|
|
setOperationAction(ISD::SUBE , MVT::i64, Expand);
|
|
|
|
|
2008-10-09 12:50:56 +08:00
|
|
|
setOperationAction(ISD::UMUL_LOHI, MVT::i64, Expand);
|
2008-11-11 14:06:07 +08:00
|
|
|
setOperationAction(ISD::SMUL_LOHI, MVT::i64, Expand);
|
2008-10-09 12:50:56 +08:00
|
|
|
|
2008-10-07 10:10:26 +08:00
|
|
|
|
2007-10-12 07:21:31 +08:00
|
|
|
// We don't support sin/cos/sqrt/pow
|
2005-09-03 02:46:02 +08:00
|
|
|
setOperationAction(ISD::FSIN , MVT::f64, Expand);
|
|
|
|
setOperationAction(ISD::FCOS , MVT::f64, Expand);
|
|
|
|
setOperationAction(ISD::FSIN , MVT::f32, Expand);
|
|
|
|
setOperationAction(ISD::FCOS , MVT::f32, Expand);
|
2006-01-20 05:10:38 +08:00
|
|
|
|
|
|
|
setOperationAction(ISD::FSQRT, MVT::f64, Expand);
|
2005-09-03 02:46:02 +08:00
|
|
|
setOperationAction(ISD::FSQRT, MVT::f32, Expand);
|
2007-10-12 07:21:31 +08:00
|
|
|
|
|
|
|
setOperationAction(ISD::FPOW , MVT::f32, Expand);
|
|
|
|
setOperationAction(ISD::FPOW , MVT::f64, Expand);
|
2008-09-04 08:47:13 +08:00
|
|
|
|
2005-12-01 01:11:20 +08:00
|
|
|
setOperationAction(ISD::SETCC, MVT::f32, Promote);
|
2005-11-29 14:16:21 +08:00
|
|
|
|
2007-01-25 05:09:16 +08:00
|
|
|
setOperationAction(ISD::BIT_CONVERT, MVT::f32, Promote);
|
|
|
|
|
2005-11-29 14:16:21 +08:00
|
|
|
// We don't have line number support yet.
|
2008-07-01 04:59:49 +08:00
|
|
|
setOperationAction(ISD::DBG_STOPPOINT, MVT::Other, Expand);
|
2006-01-05 09:47:43 +08:00
|
|
|
setOperationAction(ISD::DEBUG_LOC, MVT::Other, Expand);
|
2008-07-01 08:05:16 +08:00
|
|
|
setOperationAction(ISD::DBG_LABEL, MVT::Other, Expand);
|
|
|
|
setOperationAction(ISD::EH_LABEL, MVT::Other, Expand);
|
2006-01-13 10:42:53 +08:00
|
|
|
|
|
|
|
// Not implemented yet.
|
|
|
|
setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
|
|
|
|
setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
|
2006-01-17 05:22:38 +08:00
|
|
|
setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i64, Expand);
|
|
|
|
|
2008-09-17 05:48:12 +08:00
|
|
|
// We want to legalize GlobalAddress and ConstantPool and
|
|
|
|
// ExternalSymbols nodes into the appropriate instructions to
|
|
|
|
// materialize the address.
|
2005-12-25 09:34:27 +08:00
|
|
|
setOperationAction(ISD::GlobalAddress, MVT::i64, Custom);
|
|
|
|
setOperationAction(ISD::ConstantPool, MVT::i64, Custom);
|
2008-09-17 05:48:12 +08:00
|
|
|
setOperationAction(ISD::ExternalSymbol, MVT::i64, Custom);
|
2007-07-12 01:19:51 +08:00
|
|
|
setOperationAction(ISD::GlobalTLSAddress, MVT::i64, Custom);
|
2005-12-24 13:36:33 +08:00
|
|
|
|
2006-01-26 05:54:38 +08:00
|
|
|
setOperationAction(ISD::VASTART, MVT::Other, Custom);
|
2006-01-26 07:33:32 +08:00
|
|
|
setOperationAction(ISD::VAEND, MVT::Other, Expand);
|
2006-01-26 05:54:38 +08:00
|
|
|
setOperationAction(ISD::VACOPY, MVT::Other, Custom);
|
2006-01-26 06:28:07 +08:00
|
|
|
setOperationAction(ISD::VAARG, MVT::Other, Custom);
|
2006-01-28 11:14:31 +08:00
|
|
|
setOperationAction(ISD::VAARG, MVT::i32, Custom);
|
2006-01-26 05:54:38 +08:00
|
|
|
|
2006-06-13 02:09:24 +08:00
|
|
|
setOperationAction(ISD::RET, MVT::Other, Custom);
|
|
|
|
|
2006-09-19 02:01:03 +08:00
|
|
|
setOperationAction(ISD::JumpTable, MVT::i64, Custom);
|
2006-09-25 03:46:56 +08:00
|
|
|
setOperationAction(ISD::JumpTable, MVT::i32, Custom);
|
2006-09-19 02:01:03 +08:00
|
|
|
|
2006-01-17 05:22:38 +08:00
|
|
|
setStackPointerRegisterToSaveRestore(Alpha::R30);
|
|
|
|
|
2007-08-30 08:23:21 +08:00
|
|
|
addLegalFPImmediate(APFloat(+0.0)); //F31
|
2007-09-23 22:52:20 +08:00
|
|
|
addLegalFPImmediate(APFloat(+0.0f)); //F31
|
2007-08-30 08:23:21 +08:00
|
|
|
addLegalFPImmediate(APFloat(-0.0)); //-F31
|
2007-09-23 22:52:20 +08:00
|
|
|
addLegalFPImmediate(APFloat(-0.0f)); //-F31
|
2005-11-30 15:19:56 +08:00
|
|
|
|
2006-09-05 08:22:25 +08:00
|
|
|
setJumpBufSize(272);
|
|
|
|
setJumpBufAlignment(16);
|
|
|
|
|
2005-11-30 15:19:56 +08:00
|
|
|
computeRegisterProperties();
|
2005-09-03 02:46:02 +08:00
|
|
|
}
|
|
|
|
|
2009-01-01 23:52:00 +08:00
|
|
|
MVT AlphaTargetLowering::getSetCCResultType(MVT VT) const {
|
2008-03-10 23:42:14 +08:00
|
|
|
return MVT::i64;
|
|
|
|
}
|
|
|
|
|
2006-01-17 03:53:25 +08:00
|
|
|
const char *AlphaTargetLowering::getTargetNodeName(unsigned Opcode) const {
|
|
|
|
switch (Opcode) {
|
|
|
|
default: return 0;
|
|
|
|
case AlphaISD::CVTQT_: return "Alpha::CVTQT_";
|
|
|
|
case AlphaISD::CVTQS_: return "Alpha::CVTQS_";
|
|
|
|
case AlphaISD::CVTTQ_: return "Alpha::CVTTQ_";
|
|
|
|
case AlphaISD::GPRelHi: return "Alpha::GPRelHi";
|
|
|
|
case AlphaISD::GPRelLo: return "Alpha::GPRelLo";
|
|
|
|
case AlphaISD::RelLit: return "Alpha::RelLit";
|
2006-06-14 02:27:39 +08:00
|
|
|
case AlphaISD::GlobalRetAddr: return "Alpha::GlobalRetAddr";
|
2006-01-28 07:39:00 +08:00
|
|
|
case AlphaISD::CALL: return "Alpha::CALL";
|
2006-01-17 03:53:25 +08:00
|
|
|
case AlphaISD::DivCall: return "Alpha::DivCall";
|
2006-06-13 02:09:24 +08:00
|
|
|
case AlphaISD::RET_FLAG: return "Alpha::RET_FLAG";
|
2006-11-01 00:49:55 +08:00
|
|
|
case AlphaISD::COND_BRANCH_I: return "Alpha::COND_BRANCH_I";
|
|
|
|
case AlphaISD::COND_BRANCH_F: return "Alpha::COND_BRANCH_F";
|
2006-01-17 03:53:25 +08:00
|
|
|
}
|
|
|
|
}
|
2005-09-03 02:46:02 +08:00
|
|
|
|
2008-07-28 05:46:04 +08:00
|
|
|
static SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) {
|
2008-06-06 20:08:01 +08:00
|
|
|
MVT PtrVT = Op.getValueType();
|
2006-09-19 02:01:03 +08:00
|
|
|
JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue JTI = DAG.getTargetJumpTable(JT->getIndex(), PtrVT);
|
|
|
|
SDValue Zero = DAG.getConstant(0, PtrVT);
|
2009-02-07 05:50:26 +08:00
|
|
|
// FIXME there isn't really any debug info here
|
|
|
|
DebugLoc dl = Op.getDebugLoc();
|
2006-09-19 02:01:03 +08:00
|
|
|
|
2009-02-07 05:50:26 +08:00
|
|
|
SDValue Hi = DAG.getNode(AlphaISD::GPRelHi, dl, MVT::i64, JTI,
|
2009-02-07 08:55:49 +08:00
|
|
|
DAG.getGLOBAL_OFFSET_TABLE(MVT::i64));
|
2009-02-07 05:50:26 +08:00
|
|
|
SDValue Lo = DAG.getNode(AlphaISD::GPRelLo, dl, MVT::i64, JTI, Hi);
|
2006-09-19 02:01:03 +08:00
|
|
|
return Lo;
|
|
|
|
}
|
|
|
|
|
2006-08-12 01:19:54 +08:00
|
|
|
//http://www.cs.arizona.edu/computer.help/policy/DIGITAL_unix/
|
|
|
|
//AA-PY8AC-TET1_html/callCH3.html#BLOCK21
|
2005-09-03 02:46:02 +08:00
|
|
|
|
|
|
|
//For now, just use variable size stack frame format
|
|
|
|
|
|
|
|
//In a standard call, the first six items are passed in registers $16
|
|
|
|
//- $21 and/or registers $f16 - $f21. (See Section 4.1.2 for details
|
|
|
|
//of argument-to-register correspondence.) The remaining items are
|
|
|
|
//collected in a memory argument list that is a naturally aligned
|
|
|
|
//array of quadwords. In a standard call, this list, if present, must
|
|
|
|
//be passed at 0(SP).
|
|
|
|
//7 ... n 0(SP) ... (n-7)*8(SP)
|
|
|
|
|
|
|
|
// //#define FP $15
|
|
|
|
// //#define RA $26
|
|
|
|
// //#define PV $27
|
|
|
|
// //#define GP $29
|
|
|
|
// //#define SP $30
|
|
|
|
|
2008-07-28 05:46:04 +08:00
|
|
|
static SDValue LowerFORMAL_ARGUMENTS(SDValue Op, SelectionDAG &DAG,
|
2007-04-17 02:10:23 +08:00
|
|
|
int &VarArgsBase,
|
|
|
|
int &VarArgsOffset) {
|
2005-09-03 02:46:02 +08:00
|
|
|
MachineFunction &MF = DAG.getMachineFunction();
|
|
|
|
MachineFrameInfo *MFI = MF.getFrameInfo();
|
2008-07-28 05:46:04 +08:00
|
|
|
std::vector<SDValue> ArgValues;
|
|
|
|
SDValue Root = Op.getOperand(0);
|
2009-02-05 04:06:27 +08:00
|
|
|
DebugLoc dl = Op.getDebugLoc();
|
2006-06-13 02:09:24 +08:00
|
|
|
|
2005-09-04 14:12:19 +08:00
|
|
|
unsigned args_int[] = {
|
2005-09-03 02:46:02 +08:00
|
|
|
Alpha::R16, Alpha::R17, Alpha::R18, Alpha::R19, Alpha::R20, Alpha::R21};
|
2005-09-04 14:12:19 +08:00
|
|
|
unsigned args_float[] = {
|
2005-09-03 02:46:02 +08:00
|
|
|
Alpha::F16, Alpha::F17, Alpha::F18, Alpha::F19, Alpha::F20, Alpha::F21};
|
2006-06-13 02:09:24 +08:00
|
|
|
|
2008-08-29 05:40:38 +08:00
|
|
|
for (unsigned ArgNo = 0, e = Op.getNode()->getNumValues()-1; ArgNo != e; ++ArgNo) {
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue argt;
|
2008-06-06 20:08:01 +08:00
|
|
|
MVT ObjectVT = Op.getValue(ArgNo).getValueType();
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue ArgVal;
|
2006-06-13 02:09:24 +08:00
|
|
|
|
|
|
|
if (ArgNo < 6) {
|
2008-06-06 20:08:01 +08:00
|
|
|
switch (ObjectVT.getSimpleVT()) {
|
2005-09-03 02:46:02 +08:00
|
|
|
default:
|
2008-06-06 20:08:01 +08:00
|
|
|
assert(false && "Invalid value type!");
|
2005-09-03 02:46:02 +08:00
|
|
|
case MVT::f64:
|
2006-06-13 02:09:24 +08:00
|
|
|
args_float[ArgNo] = AddLiveIn(MF, args_float[ArgNo],
|
2007-04-17 02:10:23 +08:00
|
|
|
&Alpha::F8RCRegClass);
|
2009-02-05 04:06:27 +08:00
|
|
|
ArgVal = DAG.getCopyFromReg(Root, dl, args_float[ArgNo], ObjectVT);
|
2005-09-03 02:46:02 +08:00
|
|
|
break;
|
2006-06-21 09:00:43 +08:00
|
|
|
case MVT::f32:
|
|
|
|
args_float[ArgNo] = AddLiveIn(MF, args_float[ArgNo],
|
2007-04-17 02:10:23 +08:00
|
|
|
&Alpha::F4RCRegClass);
|
2009-02-05 04:06:27 +08:00
|
|
|
ArgVal = DAG.getCopyFromReg(Root, dl, args_float[ArgNo], ObjectVT);
|
2006-06-21 09:00:43 +08:00
|
|
|
break;
|
2005-09-03 02:46:02 +08:00
|
|
|
case MVT::i64:
|
2006-06-13 02:09:24 +08:00
|
|
|
args_int[ArgNo] = AddLiveIn(MF, args_int[ArgNo],
|
2007-04-17 02:10:23 +08:00
|
|
|
&Alpha::GPRCRegClass);
|
2009-02-05 04:06:27 +08:00
|
|
|
ArgVal = DAG.getCopyFromReg(Root, dl, args_int[ArgNo], MVT::i64);
|
2005-09-03 02:46:02 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else { //more args
|
|
|
|
// Create the frame index object for this incoming parameter...
|
2006-06-13 02:09:24 +08:00
|
|
|
int FI = MFI->CreateFixedObject(8, 8 * (ArgNo - 6));
|
2005-09-03 02:46:02 +08:00
|
|
|
|
|
|
|
// Create the SelectionDAG nodes corresponding to a load
|
|
|
|
//from this parameter
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue FIN = DAG.getFrameIndex(FI, MVT::i64);
|
2009-02-05 04:06:27 +08:00
|
|
|
ArgVal = DAG.getLoad(ObjectVT, dl, Root, FIN, NULL, 0);
|
2005-09-03 02:46:02 +08:00
|
|
|
}
|
2006-06-13 02:09:24 +08:00
|
|
|
ArgValues.push_back(ArgVal);
|
2005-09-03 02:46:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// If the functions takes variable number of arguments, copy all regs to stack
|
2008-09-13 00:56:44 +08:00
|
|
|
bool isVarArg = cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue() != 0;
|
2006-06-13 02:09:24 +08:00
|
|
|
if (isVarArg) {
|
2008-08-29 05:40:38 +08:00
|
|
|
VarArgsOffset = (Op.getNode()->getNumValues()-1) * 8;
|
2008-07-28 05:46:04 +08:00
|
|
|
std::vector<SDValue> LS;
|
2005-09-03 02:46:02 +08:00
|
|
|
for (int i = 0; i < 6; ++i) {
|
2008-02-11 02:45:23 +08:00
|
|
|
if (TargetRegisterInfo::isPhysicalRegister(args_int[i]))
|
2006-06-13 02:09:24 +08:00
|
|
|
args_int[i] = AddLiveIn(MF, args_int[i], &Alpha::GPRCRegClass);
|
2009-02-05 04:06:27 +08:00
|
|
|
SDValue argt = DAG.getCopyFromReg(Root, dl, args_int[i], MVT::i64);
|
2005-09-03 02:46:02 +08:00
|
|
|
int FI = MFI->CreateFixedObject(8, -8 * (6 - i));
|
|
|
|
if (i == 0) VarArgsBase = FI;
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue SDFI = DAG.getFrameIndex(FI, MVT::i64);
|
2009-02-05 04:06:27 +08:00
|
|
|
LS.push_back(DAG.getStore(Root, dl, argt, SDFI, NULL, 0));
|
2005-09-03 02:46:02 +08:00
|
|
|
|
2008-02-11 02:45:23 +08:00
|
|
|
if (TargetRegisterInfo::isPhysicalRegister(args_float[i]))
|
2006-06-13 02:09:24 +08:00
|
|
|
args_float[i] = AddLiveIn(MF, args_float[i], &Alpha::F8RCRegClass);
|
2009-02-05 04:06:27 +08:00
|
|
|
argt = DAG.getCopyFromReg(Root, dl, args_float[i], MVT::f64);
|
2005-09-03 02:46:02 +08:00
|
|
|
FI = MFI->CreateFixedObject(8, - 8 * (12 - i));
|
|
|
|
SDFI = DAG.getFrameIndex(FI, MVT::i64);
|
2009-02-05 04:06:27 +08:00
|
|
|
LS.push_back(DAG.getStore(Root, dl, argt, SDFI, NULL, 0));
|
2005-09-03 02:46:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//Set up a token factor with all the stack traffic
|
2009-02-05 04:06:27 +08:00
|
|
|
Root = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &LS[0], LS.size());
|
2005-09-03 02:46:02 +08:00
|
|
|
}
|
|
|
|
|
2006-06-13 02:09:24 +08:00
|
|
|
ArgValues.push_back(Root);
|
|
|
|
|
|
|
|
// Return the new list of results.
|
2009-02-05 04:06:27 +08:00
|
|
|
return DAG.getNode(ISD::MERGE_VALUES, dl, Op.getNode()->getVTList(),
|
2008-12-01 19:41:29 +08:00
|
|
|
&ArgValues[0], ArgValues.size());
|
2006-06-13 02:09:24 +08:00
|
|
|
}
|
|
|
|
|
2008-07-28 05:46:04 +08:00
|
|
|
static SDValue LowerRET(SDValue Op, SelectionDAG &DAG) {
|
2009-02-05 07:02:30 +08:00
|
|
|
DebugLoc dl = Op.getDebugLoc();
|
|
|
|
SDValue Copy = DAG.getCopyToReg(Op.getOperand(0), dl, Alpha::R26,
|
2007-04-17 02:10:23 +08:00
|
|
|
DAG.getNode(AlphaISD::GlobalRetAddr,
|
2009-02-07 08:55:49 +08:00
|
|
|
DebugLoc::getUnknownLoc(),
|
2007-04-17 02:10:23 +08:00
|
|
|
MVT::i64),
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue());
|
2006-06-13 02:09:24 +08:00
|
|
|
switch (Op.getNumOperands()) {
|
|
|
|
default:
|
|
|
|
assert(0 && "Do not know how to return this many arguments!");
|
|
|
|
abort();
|
|
|
|
case 1:
|
2006-06-14 02:27:39 +08:00
|
|
|
break;
|
2008-07-28 05:46:04 +08:00
|
|
|
//return SDValue(); // ret void is legal
|
2006-06-13 02:09:24 +08:00
|
|
|
case 3: {
|
2008-06-06 20:08:01 +08:00
|
|
|
MVT ArgVT = Op.getOperand(1).getValueType();
|
2006-06-13 02:09:24 +08:00
|
|
|
unsigned ArgReg;
|
2008-06-06 20:08:01 +08:00
|
|
|
if (ArgVT.isInteger())
|
2006-06-13 02:09:24 +08:00
|
|
|
ArgReg = Alpha::R0;
|
|
|
|
else {
|
2008-06-06 20:08:01 +08:00
|
|
|
assert(ArgVT.isFloatingPoint());
|
2006-06-13 02:09:24 +08:00
|
|
|
ArgReg = Alpha::F0;
|
|
|
|
}
|
2009-02-05 07:02:30 +08:00
|
|
|
Copy = DAG.getCopyToReg(Copy, dl, ArgReg,
|
|
|
|
Op.getOperand(1), Copy.getValue(1));
|
2007-12-31 12:13:23 +08:00
|
|
|
if (DAG.getMachineFunction().getRegInfo().liveout_empty())
|
|
|
|
DAG.getMachineFunction().getRegInfo().addLiveOut(ArgReg);
|
2005-09-03 02:46:02 +08:00
|
|
|
break;
|
|
|
|
}
|
2008-10-07 10:10:26 +08:00
|
|
|
case 5: {
|
|
|
|
MVT ArgVT = Op.getOperand(1).getValueType();
|
|
|
|
unsigned ArgReg1, ArgReg2;
|
|
|
|
if (ArgVT.isInteger()) {
|
|
|
|
ArgReg1 = Alpha::R0;
|
|
|
|
ArgReg2 = Alpha::R1;
|
|
|
|
} else {
|
|
|
|
assert(ArgVT.isFloatingPoint());
|
|
|
|
ArgReg1 = Alpha::F0;
|
|
|
|
ArgReg2 = Alpha::F1;
|
|
|
|
}
|
2009-02-05 07:02:30 +08:00
|
|
|
Copy = DAG.getCopyToReg(Copy, dl, ArgReg1,
|
|
|
|
Op.getOperand(1), Copy.getValue(1));
|
2008-10-07 10:10:26 +08:00
|
|
|
if (std::find(DAG.getMachineFunction().getRegInfo().liveout_begin(),
|
|
|
|
DAG.getMachineFunction().getRegInfo().liveout_end(), ArgReg1)
|
|
|
|
== DAG.getMachineFunction().getRegInfo().liveout_end())
|
|
|
|
DAG.getMachineFunction().getRegInfo().addLiveOut(ArgReg1);
|
2009-02-05 07:02:30 +08:00
|
|
|
Copy = DAG.getCopyToReg(Copy, dl, ArgReg2,
|
|
|
|
Op.getOperand(3), Copy.getValue(1));
|
2008-10-07 10:10:26 +08:00
|
|
|
if (std::find(DAG.getMachineFunction().getRegInfo().liveout_begin(),
|
|
|
|
DAG.getMachineFunction().getRegInfo().liveout_end(), ArgReg2)
|
|
|
|
== DAG.getMachineFunction().getRegInfo().liveout_end())
|
|
|
|
DAG.getMachineFunction().getRegInfo().addLiveOut(ArgReg2);
|
|
|
|
break;
|
|
|
|
}
|
2006-06-13 02:09:24 +08:00
|
|
|
}
|
2009-02-05 07:02:30 +08:00
|
|
|
return DAG.getNode(AlphaISD::RET_FLAG, dl,
|
|
|
|
MVT::Other, Copy, Copy.getValue(1));
|
2005-09-03 02:46:02 +08:00
|
|
|
}
|
|
|
|
|
2008-07-28 05:46:04 +08:00
|
|
|
std::pair<SDValue, SDValue>
|
|
|
|
AlphaTargetLowering::LowerCallTo(SDValue Chain, const Type *RetTy,
|
2008-02-15 01:28:50 +08:00
|
|
|
bool RetSExt, bool RetZExt, bool isVarArg,
|
2008-09-27 03:31:26 +08:00
|
|
|
bool isInreg, unsigned CallingConv,
|
|
|
|
bool isTailCall, SDValue Callee,
|
2009-01-31 07:10:59 +08:00
|
|
|
ArgListTy &Args, SelectionDAG &DAG,
|
|
|
|
DebugLoc dl) {
|
2005-09-03 02:46:02 +08:00
|
|
|
int NumBytes = 0;
|
|
|
|
if (Args.size() > 6)
|
|
|
|
NumBytes = (Args.size() - 6) * 8;
|
|
|
|
|
2008-10-12 06:08:30 +08:00
|
|
|
Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(NumBytes, true));
|
2008-07-28 05:46:04 +08:00
|
|
|
std::vector<SDValue> args_to_use;
|
2005-09-03 02:46:02 +08:00
|
|
|
for (unsigned i = 0, e = Args.size(); i != e; ++i)
|
|
|
|
{
|
2008-06-06 20:08:01 +08:00
|
|
|
switch (getValueType(Args[i].Ty).getSimpleVT()) {
|
2005-09-03 02:46:02 +08:00
|
|
|
default: assert(0 && "Unexpected ValueType for argument!");
|
|
|
|
case MVT::i1:
|
|
|
|
case MVT::i8:
|
|
|
|
case MVT::i16:
|
|
|
|
case MVT::i32:
|
|
|
|
// Promote the integer to 64 bits. If the input type is signed use a
|
|
|
|
// sign extend, otherwise use a zero extend.
|
2007-03-08 00:25:09 +08:00
|
|
|
if (Args[i].isSExt)
|
2009-01-31 07:10:59 +08:00
|
|
|
Args[i].Node = DAG.getNode(ISD::SIGN_EXTEND, dl,
|
|
|
|
MVT::i64, Args[i].Node);
|
2007-03-08 00:25:09 +08:00
|
|
|
else if (Args[i].isZExt)
|
2009-01-31 07:10:59 +08:00
|
|
|
Args[i].Node = DAG.getNode(ISD::ZERO_EXTEND, dl,
|
|
|
|
MVT::i64, Args[i].Node);
|
2007-03-08 00:25:09 +08:00
|
|
|
else
|
2009-01-31 07:10:59 +08:00
|
|
|
Args[i].Node = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i64, Args[i].Node);
|
2005-09-03 02:46:02 +08:00
|
|
|
break;
|
|
|
|
case MVT::i64:
|
|
|
|
case MVT::f64:
|
|
|
|
case MVT::f32:
|
|
|
|
break;
|
|
|
|
}
|
2006-12-31 13:55:36 +08:00
|
|
|
args_to_use.push_back(Args[i].Node);
|
2005-09-03 02:46:02 +08:00
|
|
|
}
|
|
|
|
|
2008-06-06 20:08:01 +08:00
|
|
|
std::vector<MVT> RetVals;
|
|
|
|
MVT RetTyVT = getValueType(RetTy);
|
|
|
|
MVT ActualRetTyVT = RetTyVT;
|
2008-06-09 04:54:56 +08:00
|
|
|
if (RetTyVT.getSimpleVT() >= MVT::i1 && RetTyVT.getSimpleVT() <= MVT::i32)
|
2005-09-07 01:00:23 +08:00
|
|
|
ActualRetTyVT = MVT::i64;
|
|
|
|
|
2005-09-03 02:46:02 +08:00
|
|
|
if (RetTyVT != MVT::isVoid)
|
2005-09-07 01:00:23 +08:00
|
|
|
RetVals.push_back(ActualRetTyVT);
|
2005-09-03 02:46:02 +08:00
|
|
|
RetVals.push_back(MVT::Other);
|
|
|
|
|
2008-07-28 05:46:04 +08:00
|
|
|
std::vector<SDValue> Ops;
|
2006-01-28 07:39:00 +08:00
|
|
|
Ops.push_back(Chain);
|
|
|
|
Ops.push_back(Callee);
|
|
|
|
Ops.insert(Ops.end(), args_to_use.begin(), args_to_use.end());
|
2009-01-31 07:10:59 +08:00
|
|
|
SDValue TheCall = DAG.getNode(AlphaISD::CALL, dl,
|
|
|
|
RetVals, &Ops[0], Ops.size());
|
2005-09-03 02:46:02 +08:00
|
|
|
Chain = TheCall.getValue(RetTyVT != MVT::isVoid);
|
2008-10-12 06:08:30 +08:00
|
|
|
Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(NumBytes, true),
|
|
|
|
DAG.getIntPtrConstant(0, true), SDValue());
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue RetVal = TheCall;
|
2005-09-07 01:00:23 +08:00
|
|
|
|
|
|
|
if (RetTyVT != ActualRetTyVT) {
|
2008-02-15 01:28:50 +08:00
|
|
|
ISD::NodeType AssertKind = ISD::DELETED_NODE;
|
|
|
|
if (RetSExt)
|
|
|
|
AssertKind = ISD::AssertSext;
|
|
|
|
else if (RetZExt)
|
|
|
|
AssertKind = ISD::AssertZext;
|
|
|
|
|
|
|
|
if (AssertKind != ISD::DELETED_NODE)
|
2009-01-31 07:10:59 +08:00
|
|
|
RetVal = DAG.getNode(AssertKind, dl, MVT::i64, RetVal,
|
2008-02-15 01:28:50 +08:00
|
|
|
DAG.getValueType(RetTyVT));
|
|
|
|
|
2009-01-31 07:10:59 +08:00
|
|
|
RetVal = DAG.getNode(ISD::TRUNCATE, dl, RetTyVT, RetVal);
|
2005-09-07 01:00:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return std::make_pair(RetVal, Chain);
|
2005-09-03 02:46:02 +08:00
|
|
|
}
|
|
|
|
|
2008-07-28 05:46:04 +08:00
|
|
|
void AlphaTargetLowering::LowerVAARG(SDNode *N, SDValue &Chain,
|
|
|
|
SDValue &DataPtr, SelectionDAG &DAG) {
|
2008-07-04 19:47:58 +08:00
|
|
|
Chain = N->getOperand(0);
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue VAListP = N->getOperand(1);
|
2008-07-04 19:47:58 +08:00
|
|
|
const Value *VAListS = cast<SrcValueSDNode>(N->getOperand(2))->getValue();
|
2009-02-04 09:48:28 +08:00
|
|
|
DebugLoc dl = N->getDebugLoc();
|
2008-07-04 19:47:58 +08:00
|
|
|
|
2009-02-04 09:48:28 +08:00
|
|
|
SDValue Base = DAG.getLoad(MVT::i64, dl, Chain, VAListP, VAListS, 0);
|
|
|
|
SDValue Tmp = DAG.getNode(ISD::ADD, dl, MVT::i64, VAListP,
|
2008-07-04 19:47:58 +08:00
|
|
|
DAG.getConstant(8, MVT::i64));
|
2009-02-04 09:48:28 +08:00
|
|
|
SDValue Offset = DAG.getExtLoad(ISD::SEXTLOAD, dl, MVT::i64, Base.getValue(1),
|
2008-07-04 19:47:58 +08:00
|
|
|
Tmp, NULL, 0, MVT::i32);
|
2009-02-04 09:48:28 +08:00
|
|
|
DataPtr = DAG.getNode(ISD::ADD, dl, MVT::i64, Base, Offset);
|
2008-07-04 19:47:58 +08:00
|
|
|
if (N->getValueType(0).isFloatingPoint())
|
|
|
|
{
|
|
|
|
//if fp && Offset < 6*8, then subtract 6*8 from DataPtr
|
2009-02-04 09:48:28 +08:00
|
|
|
SDValue FPDataPtr = DAG.getNode(ISD::SUB, dl, MVT::i64, DataPtr,
|
2008-07-04 19:47:58 +08:00
|
|
|
DAG.getConstant(8*6, MVT::i64));
|
2009-02-04 09:48:28 +08:00
|
|
|
SDValue CC = DAG.getSetCC(dl, MVT::i64, Offset,
|
2008-07-04 19:47:58 +08:00
|
|
|
DAG.getConstant(8*6, MVT::i64), ISD::SETLT);
|
2009-02-04 09:48:28 +08:00
|
|
|
DataPtr = DAG.getNode(ISD::SELECT, dl, MVT::i64, CC, FPDataPtr, DataPtr);
|
2008-07-04 19:47:58 +08:00
|
|
|
}
|
|
|
|
|
2009-02-04 09:48:28 +08:00
|
|
|
SDValue NewOffset = DAG.getNode(ISD::ADD, dl, MVT::i64, Offset,
|
2008-07-04 19:47:58 +08:00
|
|
|
DAG.getConstant(8, MVT::i64));
|
2009-02-04 09:48:28 +08:00
|
|
|
Chain = DAG.getTruncStore(Offset.getValue(1), dl, NewOffset, Tmp, NULL, 0,
|
2008-07-04 19:47:58 +08:00
|
|
|
MVT::i32);
|
|
|
|
}
|
|
|
|
|
2005-11-30 15:19:56 +08:00
|
|
|
/// LowerOperation - Provide custom lowering hooks for some operations.
|
|
|
|
///
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue AlphaTargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) {
|
2009-02-08 03:59:05 +08:00
|
|
|
DebugLoc dl = Op.getDebugLoc();
|
2005-11-30 15:19:56 +08:00
|
|
|
switch (Op.getOpcode()) {
|
2006-06-13 02:09:24 +08:00
|
|
|
default: assert(0 && "Wasn't expecting to be able to lower this!");
|
|
|
|
case ISD::FORMAL_ARGUMENTS: return LowerFORMAL_ARGUMENTS(Op, DAG,
|
2007-04-17 02:10:23 +08:00
|
|
|
VarArgsBase,
|
|
|
|
VarArgsOffset);
|
2006-10-12 00:24:51 +08:00
|
|
|
|
|
|
|
case ISD::RET: return LowerRET(Op,DAG);
|
2006-09-19 02:01:03 +08:00
|
|
|
case ISD::JumpTable: return LowerJumpTable(Op, DAG);
|
|
|
|
|
2008-10-07 10:10:26 +08:00
|
|
|
case ISD::INTRINSIC_WO_CHAIN: {
|
|
|
|
unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
|
|
|
|
switch (IntNo) {
|
|
|
|
default: break; // Don't custom lower most intrinsics.
|
|
|
|
case Intrinsic::alpha_umulh:
|
2009-02-07 05:50:26 +08:00
|
|
|
return DAG.getNode(ISD::MULHU, dl, MVT::i64,
|
|
|
|
Op.getOperand(1), Op.getOperand(2));
|
2008-10-07 10:10:26 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-11-30 15:19:56 +08:00
|
|
|
case ISD::SINT_TO_FP: {
|
2008-06-06 20:08:01 +08:00
|
|
|
assert(Op.getOperand(0).getValueType() == MVT::i64 &&
|
2005-11-30 15:19:56 +08:00
|
|
|
"Unhandled SINT_TO_FP type in custom expander!");
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue LD;
|
2008-06-06 20:08:01 +08:00
|
|
|
bool isDouble = Op.getValueType() == MVT::f64;
|
2009-02-07 05:50:26 +08:00
|
|
|
LD = DAG.getNode(ISD::BIT_CONVERT, dl, MVT::f64, Op.getOperand(0));
|
|
|
|
SDValue FP = DAG.getNode(isDouble?AlphaISD::CVTQT_:AlphaISD::CVTQS_, dl,
|
2005-11-30 15:19:56 +08:00
|
|
|
isDouble?MVT::f64:MVT::f32, LD);
|
|
|
|
return FP;
|
|
|
|
}
|
2005-12-01 00:10:29 +08:00
|
|
|
case ISD::FP_TO_SINT: {
|
2008-06-06 20:08:01 +08:00
|
|
|
bool isDouble = Op.getOperand(0).getValueType() == MVT::f64;
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue src = Op.getOperand(0);
|
2005-12-01 00:10:29 +08:00
|
|
|
|
|
|
|
if (!isDouble) //Promote
|
2009-02-07 05:50:26 +08:00
|
|
|
src = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, src);
|
2005-12-01 00:10:29 +08:00
|
|
|
|
2009-02-07 05:50:26 +08:00
|
|
|
src = DAG.getNode(AlphaISD::CVTTQ_, dl, MVT::f64, src);
|
2005-12-01 00:10:29 +08:00
|
|
|
|
2009-02-07 05:50:26 +08:00
|
|
|
return DAG.getNode(ISD::BIT_CONVERT, dl, MVT::i64, src);
|
2005-11-30 15:19:56 +08:00
|
|
|
}
|
2005-12-24 13:36:33 +08:00
|
|
|
case ISD::ConstantPool: {
|
2006-02-01 06:23:14 +08:00
|
|
|
ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
|
2006-09-13 05:04:05 +08:00
|
|
|
Constant *C = CP->getConstVal();
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue CPI = DAG.getTargetConstantPool(C, MVT::i64, CP->getAlignment());
|
2009-02-07 05:50:26 +08:00
|
|
|
// FIXME there isn't really any debug info here
|
2005-12-24 13:36:33 +08:00
|
|
|
|
2009-02-07 05:50:26 +08:00
|
|
|
SDValue Hi = DAG.getNode(AlphaISD::GPRelHi, dl, MVT::i64, CPI,
|
2009-02-07 08:55:49 +08:00
|
|
|
DAG.getGLOBAL_OFFSET_TABLE(MVT::i64));
|
2009-02-07 05:50:26 +08:00
|
|
|
SDValue Lo = DAG.getNode(AlphaISD::GPRelLo, dl, MVT::i64, CPI, Hi);
|
2005-12-24 13:36:33 +08:00
|
|
|
return Lo;
|
|
|
|
}
|
2007-07-12 01:19:51 +08:00
|
|
|
case ISD::GlobalTLSAddress:
|
|
|
|
assert(0 && "TLS not implemented for Alpha.");
|
2005-12-24 13:36:33 +08:00
|
|
|
case ISD::GlobalAddress: {
|
|
|
|
GlobalAddressSDNode *GSDN = cast<GlobalAddressSDNode>(Op);
|
|
|
|
GlobalValue *GV = GSDN->getGlobal();
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue GA = DAG.getTargetGlobalAddress(GV, MVT::i64, GSDN->getOffset());
|
2009-02-07 05:50:26 +08:00
|
|
|
// FIXME there isn't really any debug info here
|
2005-12-24 13:36:33 +08:00
|
|
|
|
2007-01-31 04:08:39 +08:00
|
|
|
// if (!GV->hasWeakLinkage() && !GV->isDeclaration() && !GV->hasLinkOnceLinkage()) {
|
2009-01-16 04:18:42 +08:00
|
|
|
if (GV->hasLocalLinkage()) {
|
2009-02-07 05:50:26 +08:00
|
|
|
SDValue Hi = DAG.getNode(AlphaISD::GPRelHi, dl, MVT::i64, GA,
|
2009-02-07 08:55:49 +08:00
|
|
|
DAG.getGLOBAL_OFFSET_TABLE(MVT::i64));
|
2009-02-07 05:50:26 +08:00
|
|
|
SDValue Lo = DAG.getNode(AlphaISD::GPRelLo, dl, MVT::i64, GA, Hi);
|
2005-12-24 13:36:33 +08:00
|
|
|
return Lo;
|
|
|
|
} else
|
2009-02-07 05:50:26 +08:00
|
|
|
return DAG.getNode(AlphaISD::RelLit, dl, MVT::i64, GA,
|
2009-02-07 08:55:49 +08:00
|
|
|
DAG.getGLOBAL_OFFSET_TABLE(MVT::i64));
|
2005-12-24 13:36:33 +08:00
|
|
|
}
|
2008-09-17 05:48:12 +08:00
|
|
|
case ISD::ExternalSymbol: {
|
2009-02-07 05:50:26 +08:00
|
|
|
return DAG.getNode(AlphaISD::RelLit, dl, MVT::i64,
|
2008-09-17 05:48:12 +08:00
|
|
|
DAG.getTargetExternalSymbol(cast<ExternalSymbolSDNode>(Op)
|
|
|
|
->getSymbol(), MVT::i64),
|
2009-02-07 08:55:49 +08:00
|
|
|
DAG.getGLOBAL_OFFSET_TABLE(MVT::i64));
|
2005-12-25 09:34:27 +08:00
|
|
|
}
|
2008-09-17 05:48:12 +08:00
|
|
|
|
2005-12-25 09:34:27 +08:00
|
|
|
case ISD::UREM:
|
|
|
|
case ISD::SREM:
|
2006-04-03 05:08:39 +08:00
|
|
|
//Expand only on constant case
|
|
|
|
if (Op.getOperand(1).getOpcode() == ISD::Constant) {
|
2008-08-29 05:40:38 +08:00
|
|
|
MVT VT = Op.getNode()->getValueType(0);
|
|
|
|
SDValue Tmp1 = Op.getNode()->getOpcode() == ISD::UREM ?
|
|
|
|
BuildUDIV(Op.getNode(), DAG, NULL) :
|
|
|
|
BuildSDIV(Op.getNode(), DAG, NULL);
|
2009-02-07 05:50:26 +08:00
|
|
|
Tmp1 = DAG.getNode(ISD::MUL, dl, VT, Tmp1, Op.getOperand(1));
|
|
|
|
Tmp1 = DAG.getNode(ISD::SUB, dl, VT, Op.getOperand(0), Tmp1);
|
2006-04-03 05:08:39 +08:00
|
|
|
return Tmp1;
|
|
|
|
}
|
|
|
|
//fall through
|
|
|
|
case ISD::SDIV:
|
|
|
|
case ISD::UDIV:
|
2008-06-06 20:08:01 +08:00
|
|
|
if (Op.getValueType().isInteger()) {
|
2006-04-07 05:26:32 +08:00
|
|
|
if (Op.getOperand(1).getOpcode() == ISD::Constant)
|
2008-08-29 05:40:38 +08:00
|
|
|
return Op.getOpcode() == ISD::SDIV ? BuildSDIV(Op.getNode(), DAG, NULL)
|
|
|
|
: BuildUDIV(Op.getNode(), DAG, NULL);
|
2005-12-25 09:34:27 +08:00
|
|
|
const char* opstr = 0;
|
2007-04-17 02:10:23 +08:00
|
|
|
switch (Op.getOpcode()) {
|
2005-12-25 09:34:27 +08:00
|
|
|
case ISD::UREM: opstr = "__remqu"; break;
|
|
|
|
case ISD::SREM: opstr = "__remq"; break;
|
|
|
|
case ISD::UDIV: opstr = "__divqu"; break;
|
|
|
|
case ISD::SDIV: opstr = "__divq"; break;
|
|
|
|
}
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue Tmp1 = Op.getOperand(0),
|
2005-12-25 09:34:27 +08:00
|
|
|
Tmp2 = Op.getOperand(1),
|
2008-09-17 05:48:12 +08:00
|
|
|
Addr = DAG.getExternalSymbol(opstr, MVT::i64);
|
2009-02-07 05:50:26 +08:00
|
|
|
return DAG.getNode(AlphaISD::DivCall, dl, MVT::i64, Addr, Tmp1, Tmp2);
|
2005-12-25 09:34:27 +08:00
|
|
|
}
|
|
|
|
break;
|
2005-12-01 00:10:29 +08:00
|
|
|
|
2006-01-26 02:21:52 +08:00
|
|
|
case ISD::VAARG: {
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue Chain, DataPtr;
|
2008-08-29 05:40:38 +08:00
|
|
|
LowerVAARG(Op.getNode(), Chain, DataPtr, DAG);
|
2006-01-24 05:51:33 +08:00
|
|
|
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue Result;
|
2006-01-26 02:21:52 +08:00
|
|
|
if (Op.getValueType() == MVT::i32)
|
2009-02-04 10:34:38 +08:00
|
|
|
Result = DAG.getExtLoad(ISD::SEXTLOAD, dl, MVT::i64, Chain, DataPtr,
|
2006-10-10 04:57:25 +08:00
|
|
|
NULL, 0, MVT::i32);
|
2006-01-26 02:21:52 +08:00
|
|
|
else
|
2009-02-04 10:34:38 +08:00
|
|
|
Result = DAG.getLoad(Op.getValueType(), dl, Chain, DataPtr, NULL, 0);
|
2006-01-26 02:21:52 +08:00
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
case ISD::VACOPY: {
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue Chain = Op.getOperand(0);
|
|
|
|
SDValue DestP = Op.getOperand(1);
|
|
|
|
SDValue SrcP = Op.getOperand(2);
|
2008-02-07 06:27:42 +08:00
|
|
|
const Value *DestS = cast<SrcValueSDNode>(Op.getOperand(3))->getValue();
|
|
|
|
const Value *SrcS = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
|
2006-01-26 02:21:52 +08:00
|
|
|
|
2009-02-04 10:34:38 +08:00
|
|
|
SDValue Val = DAG.getLoad(getPointerTy(), dl, Chain, SrcP, SrcS, 0);
|
|
|
|
SDValue Result = DAG.getStore(Val.getValue(1), dl, Val, DestP, DestS, 0);
|
|
|
|
SDValue NP = DAG.getNode(ISD::ADD, dl, MVT::i64, SrcP,
|
2006-01-26 02:21:52 +08:00
|
|
|
DAG.getConstant(8, MVT::i64));
|
2009-02-04 10:34:38 +08:00
|
|
|
Val = DAG.getExtLoad(ISD::SEXTLOAD, dl, MVT::i64, Result,
|
|
|
|
NP, NULL,0, MVT::i32);
|
|
|
|
SDValue NPD = DAG.getNode(ISD::ADD, dl, MVT::i64, DestP,
|
2006-01-26 02:21:52 +08:00
|
|
|
DAG.getConstant(8, MVT::i64));
|
2009-02-04 10:34:38 +08:00
|
|
|
return DAG.getTruncStore(Val.getValue(1), dl, Val, NPD, NULL, 0, MVT::i32);
|
2006-01-26 02:21:52 +08:00
|
|
|
}
|
|
|
|
case ISD::VASTART: {
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue Chain = Op.getOperand(0);
|
|
|
|
SDValue VAListP = Op.getOperand(1);
|
2008-02-07 06:27:42 +08:00
|
|
|
const Value *VAListS = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
|
2006-01-26 02:21:52 +08:00
|
|
|
|
|
|
|
// vastart stores the address of the VarArgsBase and VarArgsOffset
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue FR = DAG.getFrameIndex(VarArgsBase, MVT::i64);
|
2009-02-04 10:34:38 +08:00
|
|
|
SDValue S1 = DAG.getStore(Chain, dl, FR, VAListP, VAListS, 0);
|
|
|
|
SDValue SA2 = DAG.getNode(ISD::ADD, dl, MVT::i64, VAListP,
|
2006-01-26 02:21:52 +08:00
|
|
|
DAG.getConstant(8, MVT::i64));
|
2009-02-04 10:34:38 +08:00
|
|
|
return DAG.getTruncStore(S1, dl, DAG.getConstant(VarArgsOffset, MVT::i64),
|
2006-10-14 05:14:26 +08:00
|
|
|
SA2, NULL, 0, MVT::i32);
|
2006-01-26 02:21:52 +08:00
|
|
|
}
|
2007-02-09 01:37:41 +08:00
|
|
|
case ISD::RETURNADDR:
|
2009-02-07 08:55:49 +08:00
|
|
|
return DAG.getNode(AlphaISD::GlobalRetAddr, DebugLoc::getUnknownLoc(),
|
|
|
|
MVT::i64);
|
2007-02-09 01:37:41 +08:00
|
|
|
//FIXME: implement
|
2007-01-30 06:58:52 +08:00
|
|
|
case ISD::FRAMEADDR: break;
|
2005-12-01 00:10:29 +08:00
|
|
|
}
|
2007-02-22 06:54:50 +08:00
|
|
|
|
2008-07-28 05:46:04 +08:00
|
|
|
return SDValue();
|
2005-11-30 15:19:56 +08:00
|
|
|
}
|
2006-01-28 11:14:31 +08:00
|
|
|
|
2008-12-01 19:39:25 +08:00
|
|
|
void AlphaTargetLowering::ReplaceNodeResults(SDNode *N,
|
|
|
|
SmallVectorImpl<SDValue>&Results,
|
|
|
|
SelectionDAG &DAG) {
|
2009-02-05 04:06:27 +08:00
|
|
|
DebugLoc dl = N->getDebugLoc();
|
2008-07-04 19:47:58 +08:00
|
|
|
assert(N->getValueType(0) == MVT::i32 &&
|
|
|
|
N->getOpcode() == ISD::VAARG &&
|
2006-01-28 11:14:31 +08:00
|
|
|
"Unknown node to custom promote!");
|
2008-07-04 19:47:58 +08:00
|
|
|
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue Chain, DataPtr;
|
2008-07-04 19:47:58 +08:00
|
|
|
LowerVAARG(N, Chain, DataPtr, DAG);
|
2009-02-05 04:06:27 +08:00
|
|
|
SDValue Res = DAG.getLoad(N->getValueType(0), dl, Chain, DataPtr, NULL, 0);
|
2008-12-01 19:39:25 +08:00
|
|
|
Results.push_back(Res);
|
|
|
|
Results.push_back(SDValue(Res.getNode(), 1));
|
2006-01-28 11:14:31 +08:00
|
|
|
}
|
2006-06-21 21:37:27 +08:00
|
|
|
|
|
|
|
|
|
|
|
//Inline Asm
|
|
|
|
|
|
|
|
/// getConstraintType - Given a constraint letter, return the type of
|
|
|
|
/// constraint it is for this target.
|
|
|
|
AlphaTargetLowering::ConstraintType
|
2007-03-25 10:14:49 +08:00
|
|
|
AlphaTargetLowering::getConstraintType(const std::string &Constraint) const {
|
|
|
|
if (Constraint.size() == 1) {
|
|
|
|
switch (Constraint[0]) {
|
|
|
|
default: break;
|
|
|
|
case 'f':
|
|
|
|
case 'r':
|
|
|
|
return C_RegisterClass;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return TargetLowering::getConstraintType(Constraint);
|
2006-06-21 21:37:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<unsigned> AlphaTargetLowering::
|
|
|
|
getRegClassForInlineAsmConstraint(const std::string &Constraint,
|
2008-06-06 20:08:01 +08:00
|
|
|
MVT VT) const {
|
2006-06-21 21:37:27 +08:00
|
|
|
if (Constraint.size() == 1) {
|
|
|
|
switch (Constraint[0]) {
|
|
|
|
default: break; // Unknown constriant letter
|
|
|
|
case 'f':
|
|
|
|
return make_vector<unsigned>(Alpha::F0 , Alpha::F1 , Alpha::F2 ,
|
2007-04-17 02:10:23 +08:00
|
|
|
Alpha::F3 , Alpha::F4 , Alpha::F5 ,
|
|
|
|
Alpha::F6 , Alpha::F7 , Alpha::F8 ,
|
|
|
|
Alpha::F9 , Alpha::F10, Alpha::F11,
|
2006-06-21 21:37:27 +08:00
|
|
|
Alpha::F12, Alpha::F13, Alpha::F14,
|
2007-04-17 02:10:23 +08:00
|
|
|
Alpha::F15, Alpha::F16, Alpha::F17,
|
|
|
|
Alpha::F18, Alpha::F19, Alpha::F20,
|
|
|
|
Alpha::F21, Alpha::F22, Alpha::F23,
|
2006-06-21 21:37:27 +08:00
|
|
|
Alpha::F24, Alpha::F25, Alpha::F26,
|
2007-04-17 02:10:23 +08:00
|
|
|
Alpha::F27, Alpha::F28, Alpha::F29,
|
|
|
|
Alpha::F30, Alpha::F31, 0);
|
2006-06-21 23:42:36 +08:00
|
|
|
case 'r':
|
|
|
|
return make_vector<unsigned>(Alpha::R0 , Alpha::R1 , Alpha::R2 ,
|
2007-04-17 02:10:23 +08:00
|
|
|
Alpha::R3 , Alpha::R4 , Alpha::R5 ,
|
|
|
|
Alpha::R6 , Alpha::R7 , Alpha::R8 ,
|
|
|
|
Alpha::R9 , Alpha::R10, Alpha::R11,
|
2006-06-21 23:42:36 +08:00
|
|
|
Alpha::R12, Alpha::R13, Alpha::R14,
|
2007-04-17 02:10:23 +08:00
|
|
|
Alpha::R15, Alpha::R16, Alpha::R17,
|
|
|
|
Alpha::R18, Alpha::R19, Alpha::R20,
|
|
|
|
Alpha::R21, Alpha::R22, Alpha::R23,
|
2006-06-21 23:42:36 +08:00
|
|
|
Alpha::R24, Alpha::R25, Alpha::R26,
|
2007-04-17 02:10:23 +08:00
|
|
|
Alpha::R27, Alpha::R28, Alpha::R29,
|
|
|
|
Alpha::R30, Alpha::R31, 0);
|
2006-06-21 21:37:27 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return std::vector<unsigned>();
|
|
|
|
}
|
2008-02-21 14:45:13 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Other Lowering Code
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
MachineBasicBlock *
|
|
|
|
AlphaTargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI,
|
2009-02-08 00:15:20 +08:00
|
|
|
MachineBasicBlock *BB) const {
|
2008-02-21 14:45:13 +08:00
|
|
|
const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
|
|
|
|
assert((MI->getOpcode() == Alpha::CAS32 ||
|
|
|
|
MI->getOpcode() == Alpha::CAS64 ||
|
|
|
|
MI->getOpcode() == Alpha::LAS32 ||
|
|
|
|
MI->getOpcode() == Alpha::LAS64 ||
|
|
|
|
MI->getOpcode() == Alpha::SWAP32 ||
|
|
|
|
MI->getOpcode() == Alpha::SWAP64) &&
|
|
|
|
"Unexpected instr type to insert");
|
|
|
|
|
|
|
|
bool is32 = MI->getOpcode() == Alpha::CAS32 ||
|
|
|
|
MI->getOpcode() == Alpha::LAS32 ||
|
|
|
|
MI->getOpcode() == Alpha::SWAP32;
|
|
|
|
|
|
|
|
//Load locked store conditional for atomic ops take on the same form
|
|
|
|
//start:
|
|
|
|
//ll
|
|
|
|
//do stuff (maybe branch to exit)
|
|
|
|
//sc
|
|
|
|
//test sc and maybe branck to start
|
|
|
|
//exit:
|
|
|
|
const BasicBlock *LLVM_BB = BB->getBasicBlock();
|
2009-02-13 10:30:42 +08:00
|
|
|
DebugLoc dl = MI->getDebugLoc();
|
2008-07-08 07:14:23 +08:00
|
|
|
MachineFunction::iterator It = BB;
|
2008-02-21 14:45:13 +08:00
|
|
|
++It;
|
|
|
|
|
|
|
|
MachineBasicBlock *thisMBB = BB;
|
2008-07-08 07:14:23 +08:00
|
|
|
MachineFunction *F = BB->getParent();
|
|
|
|
MachineBasicBlock *llscMBB = F->CreateMachineBasicBlock(LLVM_BB);
|
|
|
|
MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
|
2008-02-21 14:45:13 +08:00
|
|
|
|
2008-06-22 04:21:19 +08:00
|
|
|
sinkMBB->transferSuccessors(thisMBB);
|
2008-02-21 14:45:13 +08:00
|
|
|
|
2008-07-08 07:14:23 +08:00
|
|
|
F->insert(It, llscMBB);
|
|
|
|
F->insert(It, sinkMBB);
|
2008-02-21 14:45:13 +08:00
|
|
|
|
2009-02-13 10:30:42 +08:00
|
|
|
BuildMI(thisMBB, dl, TII->get(Alpha::BR)).addMBB(llscMBB);
|
2008-02-21 14:45:13 +08:00
|
|
|
|
|
|
|
unsigned reg_res = MI->getOperand(0).getReg(),
|
|
|
|
reg_ptr = MI->getOperand(1).getReg(),
|
|
|
|
reg_v2 = MI->getOperand(2).getReg(),
|
|
|
|
reg_store = F->getRegInfo().createVirtualRegister(&Alpha::GPRCRegClass);
|
|
|
|
|
2009-02-13 10:30:42 +08:00
|
|
|
BuildMI(llscMBB, dl, TII->get(is32 ? Alpha::LDL_L : Alpha::LDQ_L),
|
2008-02-21 14:45:13 +08:00
|
|
|
reg_res).addImm(0).addReg(reg_ptr);
|
|
|
|
switch (MI->getOpcode()) {
|
|
|
|
case Alpha::CAS32:
|
|
|
|
case Alpha::CAS64: {
|
|
|
|
unsigned reg_cmp
|
|
|
|
= F->getRegInfo().createVirtualRegister(&Alpha::GPRCRegClass);
|
2009-02-13 10:30:42 +08:00
|
|
|
BuildMI(llscMBB, dl, TII->get(Alpha::CMPEQ), reg_cmp)
|
2008-02-21 14:45:13 +08:00
|
|
|
.addReg(reg_v2).addReg(reg_res);
|
2009-02-13 10:30:42 +08:00
|
|
|
BuildMI(llscMBB, dl, TII->get(Alpha::BEQ))
|
2008-02-21 14:45:13 +08:00
|
|
|
.addImm(0).addReg(reg_cmp).addMBB(sinkMBB);
|
2009-02-13 10:30:42 +08:00
|
|
|
BuildMI(llscMBB, dl, TII->get(Alpha::BISr), reg_store)
|
2008-02-21 14:45:13 +08:00
|
|
|
.addReg(Alpha::R31).addReg(MI->getOperand(3).getReg());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Alpha::LAS32:
|
|
|
|
case Alpha::LAS64: {
|
2009-02-13 10:30:42 +08:00
|
|
|
BuildMI(llscMBB, dl,TII->get(is32 ? Alpha::ADDLr : Alpha::ADDQr), reg_store)
|
2008-02-21 14:45:13 +08:00
|
|
|
.addReg(reg_res).addReg(reg_v2);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Alpha::SWAP32:
|
|
|
|
case Alpha::SWAP64: {
|
2009-02-13 10:30:42 +08:00
|
|
|
BuildMI(llscMBB, dl, TII->get(Alpha::BISr), reg_store)
|
2008-02-21 14:45:13 +08:00
|
|
|
.addReg(reg_v2).addReg(reg_v2);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-02-13 10:30:42 +08:00
|
|
|
BuildMI(llscMBB, dl, TII->get(is32 ? Alpha::STL_C : Alpha::STQ_C), reg_store)
|
2008-02-21 14:45:13 +08:00
|
|
|
.addReg(reg_store).addImm(0).addReg(reg_ptr);
|
2009-02-13 10:30:42 +08:00
|
|
|
BuildMI(llscMBB, dl, TII->get(Alpha::BEQ))
|
2008-02-21 14:45:13 +08:00
|
|
|
.addImm(0).addReg(reg_store).addMBB(llscMBB);
|
2009-02-13 10:30:42 +08:00
|
|
|
BuildMI(llscMBB, dl, TII->get(Alpha::BR)).addMBB(sinkMBB);
|
2008-02-21 14:45:13 +08:00
|
|
|
|
|
|
|
thisMBB->addSuccessor(llscMBB);
|
|
|
|
llscMBB->addSuccessor(llscMBB);
|
|
|
|
llscMBB->addSuccessor(sinkMBB);
|
2008-07-08 07:14:23 +08:00
|
|
|
F->DeleteMachineInstr(MI); // The pseudo instruction is gone now.
|
2008-02-21 14:45:13 +08:00
|
|
|
|
|
|
|
return sinkMBB;
|
|
|
|
}
|
Teach DAGCombine to fold constant offsets into GlobalAddress nodes,
and add a TargetLowering hook for it to use to determine when this
is legal (i.e. not in PIC mode, etc.)
This allows instruction selection to emit folded constant offsets
in more cases, such as the included testcase, eliminating the need
for explicit arithmetic instructions.
This eliminates the need for the C++ code in X86ISelDAGToDAG.cpp
that attempted to achieve the same effect, but wasn't as effective.
Also, fix handling of offsets in GlobalAddressSDNodes in several
places, including changing GlobalAddressSDNode's offset from
int to int64_t.
The Mips, Alpha, Sparc, and CellSPU targets appear to be
unaware of GlobalAddress offsets currently, so set the hook to
false on those targets.
llvm-svn: 57748
2008-10-18 10:06:02 +08:00
|
|
|
|
|
|
|
bool
|
|
|
|
AlphaTargetLowering::isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const {
|
|
|
|
// The Alpha target isn't yet aware of offsets.
|
|
|
|
return false;
|
|
|
|
}
|