2011-04-16 05:51:11 +08:00
|
|
|
//===-- MipsISelLowering.cpp - Mips DAG Lowering Implementation -----------===//
|
2007-06-06 15:42:06 +08:00
|
|
|
//
|
|
|
|
// 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.
|
2007-06-06 15:42:06 +08:00
|
|
|
//
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-06-06 15:42:06 +08:00
|
|
|
//
|
|
|
|
// This file defines the interfaces that Mips uses to lower LLVM code into a
|
|
|
|
// selection DAG.
|
|
|
|
//
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-06-06 15:42:06 +08:00
|
|
|
|
|
|
|
#define DEBUG_TYPE "mips-lower"
|
|
|
|
#include "MipsISelLowering.h"
|
2007-08-28 13:08:16 +08:00
|
|
|
#include "MipsMachineFunction.h"
|
2007-06-06 15:42:06 +08:00
|
|
|
#include "MipsTargetMachine.h"
|
2009-08-13 14:28:06 +08:00
|
|
|
#include "MipsTargetObjectFile.h"
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
#include "MipsSubtarget.h"
|
2007-06-06 15:42:06 +08:00
|
|
|
#include "llvm/DerivedTypes.h"
|
|
|
|
#include "llvm/Function.h"
|
2008-07-22 02:52:34 +08:00
|
|
|
#include "llvm/GlobalVariable.h"
|
2007-06-06 15:42:06 +08:00
|
|
|
#include "llvm/Intrinsics.h"
|
|
|
|
#include "llvm/CallingConv.h"
|
|
|
|
#include "llvm/CodeGen/CallingConvLower.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"
|
2007-06-06 15:42:06 +08:00
|
|
|
#include "llvm/CodeGen/SelectionDAGISel.h"
|
|
|
|
#include "llvm/CodeGen/ValueTypes.h"
|
|
|
|
#include "llvm/Support/Debug.h"
|
2009-07-12 04:10:48 +08:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2007-06-06 15:42:06 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
2009-07-28 11:13:23 +08:00
|
|
|
const char *MipsTargetLowering::getTargetNodeName(unsigned Opcode) const {
|
|
|
|
switch (Opcode) {
|
2011-05-24 05:13:59 +08:00
|
|
|
case MipsISD::JmpLink: return "MipsISD::JmpLink";
|
|
|
|
case MipsISD::Hi: return "MipsISD::Hi";
|
|
|
|
case MipsISD::Lo: return "MipsISD::Lo";
|
|
|
|
case MipsISD::GPRel: return "MipsISD::GPRel";
|
2011-05-31 10:53:58 +08:00
|
|
|
case MipsISD::TlsGd: return "MipsISD::TlsGd";
|
|
|
|
case MipsISD::TprelHi: return "MipsISD::TprelHi";
|
|
|
|
case MipsISD::TprelLo: return "MipsISD::TprelLo";
|
|
|
|
case MipsISD::ThreadPointer: return "MipsISD::ThreadPointer";
|
2011-05-24 05:13:59 +08:00
|
|
|
case MipsISD::Ret: return "MipsISD::Ret";
|
|
|
|
case MipsISD::FPBrcond: return "MipsISD::FPBrcond";
|
|
|
|
case MipsISD::FPCmp: return "MipsISD::FPCmp";
|
|
|
|
case MipsISD::CMovFP_T: return "MipsISD::CMovFP_T";
|
|
|
|
case MipsISD::CMovFP_F: return "MipsISD::CMovFP_F";
|
|
|
|
case MipsISD::FPRound: return "MipsISD::FPRound";
|
|
|
|
case MipsISD::MAdd: return "MipsISD::MAdd";
|
|
|
|
case MipsISD::MAddu: return "MipsISD::MAddu";
|
|
|
|
case MipsISD::MSub: return "MipsISD::MSub";
|
|
|
|
case MipsISD::MSubu: return "MipsISD::MSubu";
|
|
|
|
case MipsISD::DivRem: return "MipsISD::DivRem";
|
|
|
|
case MipsISD::DivRemU: return "MipsISD::DivRemU";
|
|
|
|
case MipsISD::BuildPairF64: return "MipsISD::BuildPairF64";
|
|
|
|
case MipsISD::ExtractElementF64: return "MipsISD::ExtractElementF64";
|
2011-05-28 09:07:07 +08:00
|
|
|
case MipsISD::WrapperPIC: return "MipsISD::WrapperPIC";
|
2011-06-21 08:40:49 +08:00
|
|
|
case MipsISD::DynAlloc: return "MipsISD::DynAlloc";
|
2011-06-08 02:58:42 +08:00
|
|
|
default: return NULL;
|
2007-06-06 15:42:06 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
MipsTargetLowering::
|
2009-07-28 11:13:23 +08:00
|
|
|
MipsTargetLowering(MipsTargetMachine &TM)
|
2009-08-13 14:28:06 +08:00
|
|
|
: TargetLowering(TM, new MipsTargetObjectFile()) {
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
Subtarget = &TM.getSubtarget<MipsSubtarget>();
|
|
|
|
|
2007-06-06 15:42:06 +08:00
|
|
|
// Mips does not have i1 type, so use i32 for
|
2010-11-23 11:31:01 +08:00
|
|
|
// setcc operations results (slt, sgt, ...).
|
2008-11-23 23:47:28 +08:00
|
|
|
setBooleanContents(ZeroOrOneBooleanContent);
|
2007-06-06 15:42:06 +08:00
|
|
|
|
|
|
|
// Set up the register classes
|
2009-08-12 04:47:22 +08:00
|
|
|
addRegisterClass(MVT::i32, Mips::CPURegsRegisterClass);
|
|
|
|
addRegisterClass(MVT::f32, Mips::FGR32RegisterClass);
|
2007-06-06 15:42:06 +08:00
|
|
|
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
// When dealing with single precision only, use libcalls
|
2009-03-21 08:05:07 +08:00
|
|
|
if (!Subtarget->isSingleFloat())
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
if (!Subtarget->isFP64bit())
|
2009-08-12 04:47:22 +08:00
|
|
|
addRegisterClass(MVT::f64, Mips::AFGR64RegisterClass);
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
// Load extented operations for i1 types must be promoted
|
2009-08-12 04:47:22 +08:00
|
|
|
setLoadExtAction(ISD::EXTLOAD, MVT::i1, Promote);
|
|
|
|
setLoadExtAction(ISD::ZEXTLOAD, MVT::i1, Promote);
|
|
|
|
setLoadExtAction(ISD::SEXTLOAD, MVT::i1, Promote);
|
2007-06-06 15:42:06 +08:00
|
|
|
|
2009-07-17 12:07:24 +08:00
|
|
|
// MIPS doesn't have extending float->double load/store
|
2009-08-12 04:47:22 +08:00
|
|
|
setLoadExtAction(ISD::EXTLOAD, MVT::f32, Expand);
|
|
|
|
setTruncStoreAction(MVT::f64, MVT::f32, Expand);
|
2009-07-17 10:28:12 +08:00
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
// Used by legalize types to correctly generate the setcc result.
|
|
|
|
// Without this, every float setcc comes with a AND/OR with the result,
|
|
|
|
// we don't want this, since the fpcmp result goes to a flag register,
|
2008-08-01 02:31:28 +08:00
|
|
|
// which is used implicitly by brcond and select operations.
|
2009-08-12 04:47:22 +08:00
|
|
|
AddPromotedToType(ISD::SETCC, MVT::i1, MVT::i32);
|
2008-08-01 02:31:28 +08:00
|
|
|
|
2008-07-09 12:15:08 +08:00
|
|
|
// Mips Custom Operations
|
2009-08-12 04:47:22 +08:00
|
|
|
setOperationAction(ISD::GlobalAddress, MVT::i32, Custom);
|
2011-03-05 04:01:52 +08:00
|
|
|
setOperationAction(ISD::BlockAddress, MVT::i32, Custom);
|
2009-08-12 04:47:22 +08:00
|
|
|
setOperationAction(ISD::GlobalTLSAddress, MVT::i32, Custom);
|
|
|
|
setOperationAction(ISD::JumpTable, MVT::i32, Custom);
|
|
|
|
setOperationAction(ISD::ConstantPool, MVT::i32, Custom);
|
|
|
|
setOperationAction(ISD::SELECT, MVT::f32, Custom);
|
|
|
|
setOperationAction(ISD::SELECT, MVT::f64, Custom);
|
|
|
|
setOperationAction(ISD::SELECT, MVT::i32, Custom);
|
|
|
|
setOperationAction(ISD::BRCOND, MVT::Other, Custom);
|
|
|
|
setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i32, Custom);
|
2010-02-07 05:00:02 +08:00
|
|
|
setOperationAction(ISD::VASTART, MVT::Other, Custom);
|
|
|
|
|
2011-03-05 05:03:24 +08:00
|
|
|
setOperationAction(ISD::SDIV, MVT::i32, Expand);
|
|
|
|
setOperationAction(ISD::SREM, MVT::i32, Expand);
|
|
|
|
setOperationAction(ISD::UDIV, MVT::i32, Expand);
|
|
|
|
setOperationAction(ISD::UREM, MVT::i32, Expand);
|
|
|
|
|
2008-07-09 12:15:08 +08:00
|
|
|
// Operations not directly supported by Mips.
|
2009-08-12 04:47:22 +08:00
|
|
|
setOperationAction(ISD::BR_JT, MVT::Other, Expand);
|
|
|
|
setOperationAction(ISD::BR_CC, MVT::Other, Expand);
|
|
|
|
setOperationAction(ISD::SELECT_CC, MVT::Other, Expand);
|
|
|
|
setOperationAction(ISD::UINT_TO_FP, MVT::i32, Expand);
|
|
|
|
setOperationAction(ISD::FP_TO_UINT, MVT::i32, Expand);
|
|
|
|
setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand);
|
|
|
|
setOperationAction(ISD::CTPOP, MVT::i32, Expand);
|
|
|
|
setOperationAction(ISD::CTTZ, MVT::i32, Expand);
|
|
|
|
setOperationAction(ISD::ROTL, MVT::i32, Expand);
|
2010-12-10 01:32:30 +08:00
|
|
|
|
|
|
|
if (!Subtarget->isMips32r2())
|
|
|
|
setOperationAction(ISD::ROTR, MVT::i32, Expand);
|
|
|
|
|
2009-08-12 04:47:22 +08:00
|
|
|
setOperationAction(ISD::SHL_PARTS, MVT::i32, Expand);
|
|
|
|
setOperationAction(ISD::SRA_PARTS, MVT::i32, Expand);
|
|
|
|
setOperationAction(ISD::SRL_PARTS, MVT::i32, Expand);
|
2011-05-26 03:32:07 +08:00
|
|
|
setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
|
|
|
|
setOperationAction(ISD::FCOPYSIGN, MVT::f64, Custom);
|
2009-08-12 04:47:22 +08:00
|
|
|
setOperationAction(ISD::FSIN, MVT::f32, Expand);
|
2011-03-05 02:54:14 +08:00
|
|
|
setOperationAction(ISD::FSIN, MVT::f64, Expand);
|
2009-08-12 04:47:22 +08:00
|
|
|
setOperationAction(ISD::FCOS, MVT::f32, Expand);
|
2011-03-05 02:54:14 +08:00
|
|
|
setOperationAction(ISD::FCOS, MVT::f64, Expand);
|
2009-08-12 04:47:22 +08:00
|
|
|
setOperationAction(ISD::FPOWI, MVT::f32, Expand);
|
|
|
|
setOperationAction(ISD::FPOW, MVT::f32, Expand);
|
2011-05-24 06:23:58 +08:00
|
|
|
setOperationAction(ISD::FPOW, MVT::f64, Expand);
|
2009-08-12 04:47:22 +08:00
|
|
|
setOperationAction(ISD::FLOG, MVT::f32, Expand);
|
|
|
|
setOperationAction(ISD::FLOG2, MVT::f32, Expand);
|
|
|
|
setOperationAction(ISD::FLOG10, MVT::f32, Expand);
|
|
|
|
setOperationAction(ISD::FEXP, MVT::f32, Expand);
|
2008-07-09 12:15:08 +08:00
|
|
|
|
2011-05-27 02:59:03 +08:00
|
|
|
setOperationAction(ISD::EXCEPTIONADDR, MVT::i32, Expand);
|
|
|
|
setOperationAction(ISD::EHSELECTION, MVT::i32, Expand);
|
2011-06-09 07:55:35 +08:00
|
|
|
|
2011-03-10 03:22:22 +08:00
|
|
|
setOperationAction(ISD::VAARG, MVT::Other, Expand);
|
|
|
|
setOperationAction(ISD::VACOPY, MVT::Other, Expand);
|
|
|
|
setOperationAction(ISD::VAEND, MVT::Other, Expand);
|
|
|
|
|
2008-07-09 12:15:08 +08:00
|
|
|
// Use the default for now
|
2009-08-12 04:47:22 +08:00
|
|
|
setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
|
|
|
|
setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
|
|
|
|
setOperationAction(ISD::MEMBARRIER, MVT::Other, Expand);
|
2008-07-08 03:11:24 +08:00
|
|
|
|
2008-08-04 14:44:31 +08:00
|
|
|
if (Subtarget->isSingleFloat())
|
2009-08-12 04:47:22 +08:00
|
|
|
setOperationAction(ISD::SELECT_CC, MVT::f64, Expand);
|
2007-06-06 15:42:06 +08:00
|
|
|
|
2008-07-09 13:32:22 +08:00
|
|
|
if (!Subtarget->hasSEInReg()) {
|
2009-08-12 04:47:22 +08:00
|
|
|
setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i8, Expand);
|
|
|
|
setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16, Expand);
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
}
|
|
|
|
|
2008-08-08 14:16:31 +08:00
|
|
|
if (!Subtarget->hasBitCount())
|
2009-08-12 04:47:22 +08:00
|
|
|
setOperationAction(ISD::CTLZ, MVT::i32, Expand);
|
2008-08-08 14:16:31 +08:00
|
|
|
|
2008-08-13 15:13:40 +08:00
|
|
|
if (!Subtarget->hasSwap())
|
2009-08-12 04:47:22 +08:00
|
|
|
setOperationAction(ISD::BSWAP, MVT::i32, Expand);
|
2008-08-13 15:13:40 +08:00
|
|
|
|
2011-01-19 03:29:17 +08:00
|
|
|
setTargetDAGCombine(ISD::ADDE);
|
|
|
|
setTargetDAGCombine(ISD::SUBE);
|
2011-03-05 05:03:24 +08:00
|
|
|
setTargetDAGCombine(ISD::SDIVREM);
|
|
|
|
setTargetDAGCombine(ISD::UDIVREM);
|
2011-04-01 02:26:17 +08:00
|
|
|
setTargetDAGCombine(ISD::SETCC);
|
2011-01-19 03:29:17 +08:00
|
|
|
|
2011-05-07 04:34:06 +08:00
|
|
|
setMinFunctionAlignment(2);
|
|
|
|
|
2007-06-06 15:42:06 +08:00
|
|
|
setStackPointerRegisterToSaveRestore(Mips::SP);
|
|
|
|
computeRegisterProperties();
|
2011-05-27 02:59:03 +08:00
|
|
|
|
|
|
|
setExceptionPointerRegister(Mips::A0);
|
|
|
|
setExceptionSelectorRegister(Mips::A1);
|
2007-06-06 15:42:06 +08:00
|
|
|
}
|
|
|
|
|
2009-08-12 04:47:22 +08:00
|
|
|
MVT::SimpleValueType MipsTargetLowering::getSetCCResultType(EVT VT) const {
|
|
|
|
return MVT::i32;
|
2008-03-10 23:42:14 +08:00
|
|
|
}
|
|
|
|
|
2011-01-19 03:29:17 +08:00
|
|
|
// SelectMadd -
|
|
|
|
// Transforms a subgraph in CurDAG if the following pattern is found:
|
|
|
|
// (addc multLo, Lo0), (adde multHi, Hi0),
|
|
|
|
// where,
|
|
|
|
// multHi/Lo: product of multiplication
|
2011-02-11 02:05:10 +08:00
|
|
|
// Lo0: initial value of Lo register
|
|
|
|
// Hi0: initial value of Hi register
|
2011-03-31 05:15:35 +08:00
|
|
|
// Return true if pattern matching was successful.
|
2011-01-19 03:29:17 +08:00
|
|
|
static bool SelectMadd(SDNode* ADDENode, SelectionDAG* CurDAG) {
|
2011-02-11 02:05:10 +08:00
|
|
|
// ADDENode's second operand must be a flag output of an ADDC node in order
|
2011-01-19 03:29:17 +08:00
|
|
|
// for the matching to be successful.
|
|
|
|
SDNode* ADDCNode = ADDENode->getOperand(2).getNode();
|
|
|
|
|
|
|
|
if (ADDCNode->getOpcode() != ISD::ADDC)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
SDValue MultHi = ADDENode->getOperand(0);
|
|
|
|
SDValue MultLo = ADDCNode->getOperand(0);
|
2011-02-11 02:05:10 +08:00
|
|
|
SDNode* MultNode = MultHi.getNode();
|
2011-01-19 03:29:17 +08:00
|
|
|
unsigned MultOpc = MultHi.getOpcode();
|
|
|
|
|
|
|
|
// MultHi and MultLo must be generated by the same node,
|
|
|
|
if (MultLo.getNode() != MultNode)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// and it must be a multiplication.
|
|
|
|
if (MultOpc != ISD::SMUL_LOHI && MultOpc != ISD::UMUL_LOHI)
|
|
|
|
return false;
|
2011-02-11 02:05:10 +08:00
|
|
|
|
|
|
|
// MultLo amd MultHi must be the first and second output of MultNode
|
|
|
|
// respectively.
|
2011-01-19 03:29:17 +08:00
|
|
|
if (MultHi.getResNo() != 1 || MultLo.getResNo() != 0)
|
|
|
|
return false;
|
|
|
|
|
2011-02-11 02:05:10 +08:00
|
|
|
// Transform this to a MADD only if ADDENode and ADDCNode are the only users
|
2011-01-19 03:29:17 +08:00
|
|
|
// of the values of MultNode, in which case MultNode will be removed in later
|
|
|
|
// phases.
|
2011-04-16 05:51:11 +08:00
|
|
|
// If there exist users other than ADDENode or ADDCNode, this function returns
|
|
|
|
// here, which will result in MultNode being mapped to a single MULT
|
2011-02-11 02:05:10 +08:00
|
|
|
// instruction node rather than a pair of MULT and MADD instructions being
|
2011-01-19 03:29:17 +08:00
|
|
|
// produced.
|
|
|
|
if (!MultHi.hasOneUse() || !MultLo.hasOneUse())
|
|
|
|
return false;
|
|
|
|
|
2011-02-11 02:05:10 +08:00
|
|
|
SDValue Chain = CurDAG->getEntryNode();
|
2011-01-19 03:29:17 +08:00
|
|
|
DebugLoc dl = ADDENode->getDebugLoc();
|
|
|
|
|
|
|
|
// create MipsMAdd(u) node
|
|
|
|
MultOpc = MultOpc == ISD::UMUL_LOHI ? MipsISD::MAddu : MipsISD::MAdd;
|
2011-02-11 02:05:10 +08:00
|
|
|
|
2011-01-19 03:29:17 +08:00
|
|
|
SDValue MAdd = CurDAG->getNode(MultOpc, dl,
|
|
|
|
MVT::Glue,
|
|
|
|
MultNode->getOperand(0),// Factor 0
|
|
|
|
MultNode->getOperand(1),// Factor 1
|
2011-02-11 02:05:10 +08:00
|
|
|
ADDCNode->getOperand(1),// Lo0
|
2011-01-19 03:29:17 +08:00
|
|
|
ADDENode->getOperand(1));// Hi0
|
|
|
|
|
|
|
|
// create CopyFromReg nodes
|
|
|
|
SDValue CopyFromLo = CurDAG->getCopyFromReg(Chain, dl, Mips::LO, MVT::i32,
|
|
|
|
MAdd);
|
2011-02-11 02:05:10 +08:00
|
|
|
SDValue CopyFromHi = CurDAG->getCopyFromReg(CopyFromLo.getValue(1), dl,
|
2011-01-19 03:29:17 +08:00
|
|
|
Mips::HI, MVT::i32,
|
|
|
|
CopyFromLo.getValue(2));
|
|
|
|
|
|
|
|
// replace uses of adde and addc here
|
|
|
|
if (!SDValue(ADDCNode, 0).use_empty())
|
|
|
|
CurDAG->ReplaceAllUsesOfValueWith(SDValue(ADDCNode, 0), CopyFromLo);
|
|
|
|
|
|
|
|
if (!SDValue(ADDENode, 0).use_empty())
|
|
|
|
CurDAG->ReplaceAllUsesOfValueWith(SDValue(ADDENode, 0), CopyFromHi);
|
|
|
|
|
2011-02-11 02:05:10 +08:00
|
|
|
return true;
|
2011-01-19 03:29:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// SelectMsub -
|
|
|
|
// Transforms a subgraph in CurDAG if the following pattern is found:
|
|
|
|
// (addc Lo0, multLo), (sube Hi0, multHi),
|
|
|
|
// where,
|
|
|
|
// multHi/Lo: product of multiplication
|
2011-02-11 02:05:10 +08:00
|
|
|
// Lo0: initial value of Lo register
|
|
|
|
// Hi0: initial value of Hi register
|
2011-03-31 05:15:35 +08:00
|
|
|
// Return true if pattern matching was successful.
|
2011-01-19 03:29:17 +08:00
|
|
|
static bool SelectMsub(SDNode* SUBENode, SelectionDAG* CurDAG) {
|
2011-02-11 02:05:10 +08:00
|
|
|
// SUBENode's second operand must be a flag output of an SUBC node in order
|
2011-01-19 03:29:17 +08:00
|
|
|
// for the matching to be successful.
|
|
|
|
SDNode* SUBCNode = SUBENode->getOperand(2).getNode();
|
|
|
|
|
|
|
|
if (SUBCNode->getOpcode() != ISD::SUBC)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
SDValue MultHi = SUBENode->getOperand(1);
|
|
|
|
SDValue MultLo = SUBCNode->getOperand(1);
|
2011-02-11 02:05:10 +08:00
|
|
|
SDNode* MultNode = MultHi.getNode();
|
2011-01-19 03:29:17 +08:00
|
|
|
unsigned MultOpc = MultHi.getOpcode();
|
|
|
|
|
|
|
|
// MultHi and MultLo must be generated by the same node,
|
|
|
|
if (MultLo.getNode() != MultNode)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// and it must be a multiplication.
|
|
|
|
if (MultOpc != ISD::SMUL_LOHI && MultOpc != ISD::UMUL_LOHI)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// MultLo amd MultHi must be the first and second output of MultNode
|
|
|
|
// respectively.
|
|
|
|
if (MultHi.getResNo() != 1 || MultLo.getResNo() != 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Transform this to a MSUB only if SUBENode and SUBCNode are the only users
|
|
|
|
// of the values of MultNode, in which case MultNode will be removed in later
|
|
|
|
// phases.
|
2011-04-16 05:51:11 +08:00
|
|
|
// If there exist users other than SUBENode or SUBCNode, this function returns
|
|
|
|
// here, which will result in MultNode being mapped to a single MULT
|
2011-01-19 03:29:17 +08:00
|
|
|
// instruction node rather than a pair of MULT and MSUB instructions being
|
|
|
|
// produced.
|
|
|
|
if (!MultHi.hasOneUse() || !MultLo.hasOneUse())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
SDValue Chain = CurDAG->getEntryNode();
|
|
|
|
DebugLoc dl = SUBENode->getDebugLoc();
|
|
|
|
|
|
|
|
// create MipsSub(u) node
|
|
|
|
MultOpc = MultOpc == ISD::UMUL_LOHI ? MipsISD::MSubu : MipsISD::MSub;
|
|
|
|
|
|
|
|
SDValue MSub = CurDAG->getNode(MultOpc, dl,
|
|
|
|
MVT::Glue,
|
|
|
|
MultNode->getOperand(0),// Factor 0
|
|
|
|
MultNode->getOperand(1),// Factor 1
|
|
|
|
SUBCNode->getOperand(0),// Lo0
|
|
|
|
SUBENode->getOperand(0));// Hi0
|
|
|
|
|
|
|
|
// create CopyFromReg nodes
|
|
|
|
SDValue CopyFromLo = CurDAG->getCopyFromReg(Chain, dl, Mips::LO, MVT::i32,
|
|
|
|
MSub);
|
|
|
|
SDValue CopyFromHi = CurDAG->getCopyFromReg(CopyFromLo.getValue(1), dl,
|
|
|
|
Mips::HI, MVT::i32,
|
|
|
|
CopyFromLo.getValue(2));
|
|
|
|
|
|
|
|
// replace uses of sube and subc here
|
|
|
|
if (!SDValue(SUBCNode, 0).use_empty())
|
|
|
|
CurDAG->ReplaceAllUsesOfValueWith(SDValue(SUBCNode, 0), CopyFromLo);
|
|
|
|
|
|
|
|
if (!SDValue(SUBENode, 0).use_empty())
|
|
|
|
CurDAG->ReplaceAllUsesOfValueWith(SDValue(SUBENode, 0), CopyFromHi);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static SDValue PerformADDECombine(SDNode *N, SelectionDAG& DAG,
|
|
|
|
TargetLowering::DAGCombinerInfo &DCI,
|
|
|
|
const MipsSubtarget* Subtarget) {
|
|
|
|
if (DCI.isBeforeLegalize())
|
|
|
|
return SDValue();
|
|
|
|
|
|
|
|
if (Subtarget->isMips32() && SelectMadd(N, &DAG))
|
|
|
|
return SDValue(N, 0);
|
2011-02-11 02:05:10 +08:00
|
|
|
|
2011-01-19 03:29:17 +08:00
|
|
|
return SDValue();
|
2011-02-11 02:05:10 +08:00
|
|
|
}
|
2011-01-19 03:29:17 +08:00
|
|
|
|
|
|
|
static SDValue PerformSUBECombine(SDNode *N, SelectionDAG& DAG,
|
|
|
|
TargetLowering::DAGCombinerInfo &DCI,
|
|
|
|
const MipsSubtarget* Subtarget) {
|
|
|
|
if (DCI.isBeforeLegalize())
|
|
|
|
return SDValue();
|
|
|
|
|
|
|
|
if (Subtarget->isMips32() && SelectMsub(N, &DAG))
|
|
|
|
return SDValue(N, 0);
|
2011-02-11 02:05:10 +08:00
|
|
|
|
2011-01-19 03:29:17 +08:00
|
|
|
return SDValue();
|
2011-02-11 02:05:10 +08:00
|
|
|
}
|
2011-01-19 03:29:17 +08:00
|
|
|
|
2011-03-05 05:03:24 +08:00
|
|
|
static SDValue PerformDivRemCombine(SDNode *N, SelectionDAG& DAG,
|
|
|
|
TargetLowering::DAGCombinerInfo &DCI,
|
|
|
|
const MipsSubtarget* Subtarget) {
|
|
|
|
if (DCI.isBeforeLegalizeOps())
|
|
|
|
return SDValue();
|
|
|
|
|
|
|
|
unsigned opc = N->getOpcode() == ISD::SDIVREM ? MipsISD::DivRem :
|
|
|
|
MipsISD::DivRemU;
|
|
|
|
DebugLoc dl = N->getDebugLoc();
|
|
|
|
|
|
|
|
SDValue DivRem = DAG.getNode(opc, dl, MVT::Glue,
|
|
|
|
N->getOperand(0), N->getOperand(1));
|
|
|
|
SDValue InChain = DAG.getEntryNode();
|
|
|
|
SDValue InGlue = DivRem;
|
|
|
|
|
|
|
|
// insert MFLO
|
|
|
|
if (N->hasAnyUseOfValue(0)) {
|
|
|
|
SDValue CopyFromLo = DAG.getCopyFromReg(InChain, dl, Mips::LO, MVT::i32,
|
|
|
|
InGlue);
|
|
|
|
DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), CopyFromLo);
|
|
|
|
InChain = CopyFromLo.getValue(1);
|
|
|
|
InGlue = CopyFromLo.getValue(2);
|
|
|
|
}
|
|
|
|
|
|
|
|
// insert MFHI
|
|
|
|
if (N->hasAnyUseOfValue(1)) {
|
|
|
|
SDValue CopyFromHi = DAG.getCopyFromReg(InChain, dl,
|
2011-05-24 05:13:59 +08:00
|
|
|
Mips::HI, MVT::i32, InGlue);
|
2011-03-05 05:03:24 +08:00
|
|
|
DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1), CopyFromHi);
|
|
|
|
}
|
|
|
|
|
|
|
|
return SDValue();
|
|
|
|
}
|
|
|
|
|
2011-04-01 02:26:17 +08:00
|
|
|
static Mips::CondCode FPCondCCodeToFCC(ISD::CondCode CC) {
|
|
|
|
switch (CC) {
|
|
|
|
default: llvm_unreachable("Unknown fp condition code!");
|
|
|
|
case ISD::SETEQ:
|
|
|
|
case ISD::SETOEQ: return Mips::FCOND_OEQ;
|
|
|
|
case ISD::SETUNE: return Mips::FCOND_UNE;
|
|
|
|
case ISD::SETLT:
|
|
|
|
case ISD::SETOLT: return Mips::FCOND_OLT;
|
|
|
|
case ISD::SETGT:
|
|
|
|
case ISD::SETOGT: return Mips::FCOND_OGT;
|
|
|
|
case ISD::SETLE:
|
|
|
|
case ISD::SETOLE: return Mips::FCOND_OLE;
|
|
|
|
case ISD::SETGE:
|
|
|
|
case ISD::SETOGE: return Mips::FCOND_OGE;
|
|
|
|
case ISD::SETULT: return Mips::FCOND_ULT;
|
|
|
|
case ISD::SETULE: return Mips::FCOND_ULE;
|
|
|
|
case ISD::SETUGT: return Mips::FCOND_UGT;
|
|
|
|
case ISD::SETUGE: return Mips::FCOND_UGE;
|
|
|
|
case ISD::SETUO: return Mips::FCOND_UN;
|
|
|
|
case ISD::SETO: return Mips::FCOND_OR;
|
|
|
|
case ISD::SETNE:
|
|
|
|
case ISD::SETONE: return Mips::FCOND_ONE;
|
|
|
|
case ISD::SETUEQ: return Mips::FCOND_UEQ;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Returns true if condition code has to be inverted.
|
|
|
|
static bool InvertFPCondCode(Mips::CondCode CC) {
|
|
|
|
if (CC >= Mips::FCOND_F && CC <= Mips::FCOND_NGT)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (CC >= Mips::FCOND_T && CC <= Mips::FCOND_GT)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
assert(false && "Illegal Condition Code");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Creates and returns an FPCmp node from a setcc node.
|
|
|
|
// Returns Op if setcc is not a floating point comparison.
|
|
|
|
static SDValue CreateFPCmp(SelectionDAG& DAG, const SDValue& Op) {
|
|
|
|
// must be a SETCC node
|
|
|
|
if (Op.getOpcode() != ISD::SETCC)
|
|
|
|
return Op;
|
|
|
|
|
|
|
|
SDValue LHS = Op.getOperand(0);
|
|
|
|
|
|
|
|
if (!LHS.getValueType().isFloatingPoint())
|
|
|
|
return Op;
|
|
|
|
|
|
|
|
SDValue RHS = Op.getOperand(1);
|
|
|
|
DebugLoc dl = Op.getDebugLoc();
|
|
|
|
|
2011-04-16 05:00:26 +08:00
|
|
|
// Assume the 3rd operand is a CondCodeSDNode. Add code to check the type of
|
|
|
|
// node if necessary.
|
2011-04-01 02:26:17 +08:00
|
|
|
ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get();
|
|
|
|
|
|
|
|
return DAG.getNode(MipsISD::FPCmp, dl, MVT::Glue, LHS, RHS,
|
|
|
|
DAG.getConstant(FPCondCCodeToFCC(CC), MVT::i32));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Creates and returns a CMovFPT/F node.
|
|
|
|
static SDValue CreateCMovFP(SelectionDAG& DAG, SDValue Cond, SDValue True,
|
|
|
|
SDValue False, DebugLoc DL) {
|
|
|
|
bool invert = InvertFPCondCode((Mips::CondCode)
|
|
|
|
cast<ConstantSDNode>(Cond.getOperand(2))
|
|
|
|
->getSExtValue());
|
|
|
|
|
|
|
|
return DAG.getNode((invert ? MipsISD::CMovFP_F : MipsISD::CMovFP_T), DL,
|
|
|
|
True.getValueType(), True, False, Cond);
|
|
|
|
}
|
|
|
|
|
|
|
|
static SDValue PerformSETCCCombine(SDNode *N, SelectionDAG& DAG,
|
|
|
|
TargetLowering::DAGCombinerInfo &DCI,
|
|
|
|
const MipsSubtarget* Subtarget) {
|
|
|
|
if (DCI.isBeforeLegalizeOps())
|
|
|
|
return SDValue();
|
|
|
|
|
|
|
|
SDValue Cond = CreateFPCmp(DAG, SDValue(N, 0));
|
|
|
|
|
|
|
|
if (Cond.getOpcode() != MipsISD::FPCmp)
|
|
|
|
return SDValue();
|
|
|
|
|
|
|
|
SDValue True = DAG.getConstant(1, MVT::i32);
|
|
|
|
SDValue False = DAG.getConstant(0, MVT::i32);
|
|
|
|
|
|
|
|
return CreateCMovFP(DAG, Cond, True, False, N->getDebugLoc());
|
|
|
|
}
|
|
|
|
|
2011-02-11 02:05:10 +08:00
|
|
|
SDValue MipsTargetLowering::PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI)
|
2011-01-19 03:29:17 +08:00
|
|
|
const {
|
|
|
|
SelectionDAG &DAG = DCI.DAG;
|
|
|
|
unsigned opc = N->getOpcode();
|
|
|
|
|
|
|
|
switch (opc) {
|
|
|
|
default: break;
|
|
|
|
case ISD::ADDE:
|
|
|
|
return PerformADDECombine(N, DAG, DCI, Subtarget);
|
|
|
|
case ISD::SUBE:
|
|
|
|
return PerformSUBECombine(N, DAG, DCI, Subtarget);
|
2011-03-05 05:03:24 +08:00
|
|
|
case ISD::SDIVREM:
|
|
|
|
case ISD::UDIVREM:
|
|
|
|
return PerformDivRemCombine(N, DAG, DCI, Subtarget);
|
2011-04-01 02:26:17 +08:00
|
|
|
case ISD::SETCC:
|
|
|
|
return PerformSETCCCombine(N, DAG, DCI, Subtarget);
|
2011-01-19 03:29:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return SDValue();
|
|
|
|
}
|
|
|
|
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue MipsTargetLowering::
|
2010-04-17 23:26:15 +08:00
|
|
|
LowerOperation(SDValue Op, SelectionDAG &DAG) const
|
2007-06-06 15:42:06 +08:00
|
|
|
{
|
2010-11-23 11:31:01 +08:00
|
|
|
switch (Op.getOpcode())
|
2007-06-06 15:42:06 +08:00
|
|
|
{
|
2008-08-08 03:08:11 +08:00
|
|
|
case ISD::BRCOND: return LowerBRCOND(Op, DAG);
|
|
|
|
case ISD::ConstantPool: return LowerConstantPool(Op, DAG);
|
|
|
|
case ISD::DYNAMIC_STACKALLOC: return LowerDYNAMIC_STACKALLOC(Op, DAG);
|
|
|
|
case ISD::GlobalAddress: return LowerGlobalAddress(Op, DAG);
|
2011-03-05 04:01:52 +08:00
|
|
|
case ISD::BlockAddress: return LowerBlockAddress(Op, DAG);
|
2008-08-08 03:08:11 +08:00
|
|
|
case ISD::GlobalTLSAddress: return LowerGlobalTLSAddress(Op, DAG);
|
|
|
|
case ISD::JumpTable: return LowerJumpTable(Op, DAG);
|
|
|
|
case ISD::SELECT: return LowerSELECT(Op, DAG);
|
2010-02-07 05:00:02 +08:00
|
|
|
case ISD::VASTART: return LowerVASTART(Op, DAG);
|
2011-05-26 03:32:07 +08:00
|
|
|
case ISD::FCOPYSIGN: return LowerFCOPYSIGN(Op, DAG);
|
2011-06-02 08:24:44 +08:00
|
|
|
case ISD::FRAMEADDR: return LowerFRAMEADDR(Op, DAG);
|
2007-06-06 15:42:06 +08:00
|
|
|
}
|
2008-07-28 05:46:04 +08:00
|
|
|
return SDValue();
|
2007-06-06 15:42:06 +08:00
|
|
|
}
|
|
|
|
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-06-06 15:42:06 +08:00
|
|
|
// Lower helper functions
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-06-06 15:42:06 +08:00
|
|
|
|
|
|
|
// 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
|
2010-11-23 11:31:01 +08:00
|
|
|
AddLiveIn(MachineFunction &MF, unsigned PReg, TargetRegisterClass *RC)
|
2007-06-06 15:42:06 +08:00
|
|
|
{
|
|
|
|
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);
|
2007-06-06 15:42:06 +08:00
|
|
|
return VReg;
|
|
|
|
}
|
|
|
|
|
2008-07-29 03:11:24 +08:00
|
|
|
// Get fp branch code (not opcode) from condition code.
|
|
|
|
static Mips::FPBranchCode GetFPBranchCodeFromCond(Mips::CondCode CC) {
|
|
|
|
if (CC >= Mips::FCOND_F && CC <= Mips::FCOND_NGT)
|
|
|
|
return Mips::BRANCH_T;
|
|
|
|
|
|
|
|
if (CC >= Mips::FCOND_T && CC <= Mips::FCOND_GT)
|
|
|
|
return Mips::BRANCH_F;
|
|
|
|
|
|
|
|
return Mips::BRANCH_INVALID;
|
|
|
|
}
|
2010-11-23 11:31:01 +08:00
|
|
|
|
2011-06-08 03:28:39 +08:00
|
|
|
static MachineBasicBlock* ExpandCondMov(MachineInstr *MI, MachineBasicBlock *BB,
|
|
|
|
DebugLoc dl,
|
|
|
|
const MipsSubtarget* Subtarget,
|
|
|
|
const TargetInstrInfo *TII,
|
|
|
|
bool isFPCmp, unsigned Opc) {
|
2011-05-31 10:54:07 +08:00
|
|
|
// There is no need to expand CMov instructions if target has
|
|
|
|
// conditional moves.
|
|
|
|
if (Subtarget->hasCondMov())
|
|
|
|
return BB;
|
|
|
|
|
2011-04-01 02:26:17 +08:00
|
|
|
// To "insert" a SELECT_CC instruction, we actually have to insert the
|
|
|
|
// diamond control-flow pattern. The incoming instruction knows the
|
|
|
|
// destination vreg to set, the condition code register to branch on, the
|
|
|
|
// true/false values to select between, and a branch opcode to use.
|
|
|
|
const BasicBlock *LLVM_BB = BB->getBasicBlock();
|
|
|
|
MachineFunction::iterator It = BB;
|
|
|
|
++It;
|
|
|
|
|
|
|
|
// thisMBB:
|
|
|
|
// ...
|
|
|
|
// TrueVal = ...
|
|
|
|
// setcc r1, r2, r3
|
|
|
|
// bNE r1, r0, copy1MBB
|
|
|
|
// fallthrough --> copy0MBB
|
|
|
|
MachineBasicBlock *thisMBB = BB;
|
|
|
|
MachineFunction *F = BB->getParent();
|
|
|
|
MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
|
|
|
|
MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
|
|
|
|
F->insert(It, copy0MBB);
|
|
|
|
F->insert(It, sinkMBB);
|
|
|
|
|
|
|
|
// Transfer the remainder of BB and its successor edges to sinkMBB.
|
|
|
|
sinkMBB->splice(sinkMBB->begin(), BB,
|
|
|
|
llvm::next(MachineBasicBlock::iterator(MI)),
|
|
|
|
BB->end());
|
|
|
|
sinkMBB->transferSuccessorsAndUpdatePHIs(BB);
|
|
|
|
|
|
|
|
// Next, add the true and fallthrough blocks as its successors.
|
|
|
|
BB->addSuccessor(copy0MBB);
|
|
|
|
BB->addSuccessor(sinkMBB);
|
|
|
|
|
|
|
|
// Emit the right instruction according to the type of the operands compared
|
|
|
|
if (isFPCmp)
|
|
|
|
BuildMI(BB, dl, TII->get(Opc)).addMBB(sinkMBB);
|
|
|
|
else
|
|
|
|
BuildMI(BB, dl, TII->get(Opc)).addReg(MI->getOperand(2).getReg())
|
|
|
|
.addReg(Mips::ZERO).addMBB(sinkMBB);
|
|
|
|
|
|
|
|
// copy0MBB:
|
|
|
|
// %FalseValue = ...
|
|
|
|
// # fallthrough to sinkMBB
|
|
|
|
BB = copy0MBB;
|
|
|
|
|
|
|
|
// Update machine-CFG edges
|
|
|
|
BB->addSuccessor(sinkMBB);
|
|
|
|
|
|
|
|
// sinkMBB:
|
|
|
|
// %Result = phi [ %TrueValue, thisMBB ], [ %FalseValue, copy0MBB ]
|
|
|
|
// ...
|
|
|
|
BB = sinkMBB;
|
|
|
|
|
|
|
|
if (isFPCmp)
|
2010-07-07 04:24:04 +08:00
|
|
|
BuildMI(*BB, BB->begin(), dl,
|
|
|
|
TII->get(Mips::PHI), MI->getOperand(0).getReg())
|
2010-07-20 15:58:51 +08:00
|
|
|
.addReg(MI->getOperand(2).getReg()).addMBB(thisMBB)
|
2011-04-01 02:26:17 +08:00
|
|
|
.addReg(MI->getOperand(1).getReg()).addMBB(copy0MBB);
|
|
|
|
else
|
|
|
|
BuildMI(*BB, BB->begin(), dl,
|
|
|
|
TII->get(Mips::PHI), MI->getOperand(0).getReg())
|
|
|
|
.addReg(MI->getOperand(3).getReg()).addMBB(thisMBB)
|
|
|
|
.addReg(MI->getOperand(1).getReg()).addMBB(copy0MBB);
|
2008-07-30 03:05:28 +08:00
|
|
|
|
2011-04-01 02:26:17 +08:00
|
|
|
MI->eraseFromParent(); // The pseudo instruction is gone now.
|
|
|
|
return BB;
|
2008-07-30 03:05:28 +08:00
|
|
|
}
|
|
|
|
|
2011-06-08 03:28:39 +08:00
|
|
|
MachineBasicBlock *
|
|
|
|
MipsTargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI,
|
|
|
|
MachineBasicBlock *BB) const {
|
|
|
|
const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
|
|
|
|
DebugLoc dl = MI->getDebugLoc();
|
|
|
|
|
|
|
|
switch (MI->getOpcode()) {
|
|
|
|
default:
|
|
|
|
assert(false && "Unexpected instr type to insert");
|
|
|
|
return NULL;
|
|
|
|
case Mips::MOVT:
|
|
|
|
case Mips::MOVT_S:
|
|
|
|
case Mips::MOVT_D:
|
|
|
|
return ExpandCondMov(MI, BB, dl, Subtarget, TII, true, Mips::BC1F);
|
|
|
|
case Mips::MOVF:
|
|
|
|
case Mips::MOVF_S:
|
|
|
|
case Mips::MOVF_D:
|
|
|
|
return ExpandCondMov(MI, BB, dl, Subtarget, TII, true, Mips::BC1T);
|
|
|
|
case Mips::MOVZ_I:
|
|
|
|
case Mips::MOVZ_S:
|
|
|
|
case Mips::MOVZ_D:
|
|
|
|
return ExpandCondMov(MI, BB, dl, Subtarget, TII, false, Mips::BNE);
|
|
|
|
case Mips::MOVN_I:
|
|
|
|
case Mips::MOVN_S:
|
|
|
|
case Mips::MOVN_D:
|
|
|
|
return ExpandCondMov(MI, BB, dl, Subtarget, TII, false, Mips::BEQ);
|
|
|
|
|
|
|
|
case Mips::ATOMIC_LOAD_ADD_I8:
|
|
|
|
return EmitAtomicBinaryPartword(MI, BB, 1, Mips::ADDu);
|
|
|
|
case Mips::ATOMIC_LOAD_ADD_I16:
|
|
|
|
return EmitAtomicBinaryPartword(MI, BB, 2, Mips::ADDu);
|
|
|
|
case Mips::ATOMIC_LOAD_ADD_I32:
|
|
|
|
return EmitAtomicBinary(MI, BB, 4, Mips::ADDu);
|
|
|
|
|
|
|
|
case Mips::ATOMIC_LOAD_AND_I8:
|
|
|
|
return EmitAtomicBinaryPartword(MI, BB, 1, Mips::AND);
|
|
|
|
case Mips::ATOMIC_LOAD_AND_I16:
|
|
|
|
return EmitAtomicBinaryPartword(MI, BB, 2, Mips::AND);
|
|
|
|
case Mips::ATOMIC_LOAD_AND_I32:
|
|
|
|
return EmitAtomicBinary(MI, BB, 4, Mips::AND);
|
|
|
|
|
|
|
|
case Mips::ATOMIC_LOAD_OR_I8:
|
|
|
|
return EmitAtomicBinaryPartword(MI, BB, 1, Mips::OR);
|
|
|
|
case Mips::ATOMIC_LOAD_OR_I16:
|
|
|
|
return EmitAtomicBinaryPartword(MI, BB, 2, Mips::OR);
|
|
|
|
case Mips::ATOMIC_LOAD_OR_I32:
|
|
|
|
return EmitAtomicBinary(MI, BB, 4, Mips::OR);
|
|
|
|
|
|
|
|
case Mips::ATOMIC_LOAD_XOR_I8:
|
|
|
|
return EmitAtomicBinaryPartword(MI, BB, 1, Mips::XOR);
|
|
|
|
case Mips::ATOMIC_LOAD_XOR_I16:
|
|
|
|
return EmitAtomicBinaryPartword(MI, BB, 2, Mips::XOR);
|
|
|
|
case Mips::ATOMIC_LOAD_XOR_I32:
|
|
|
|
return EmitAtomicBinary(MI, BB, 4, Mips::XOR);
|
|
|
|
|
|
|
|
case Mips::ATOMIC_LOAD_NAND_I8:
|
|
|
|
return EmitAtomicBinaryPartword(MI, BB, 1, 0, true);
|
|
|
|
case Mips::ATOMIC_LOAD_NAND_I16:
|
|
|
|
return EmitAtomicBinaryPartword(MI, BB, 2, 0, true);
|
|
|
|
case Mips::ATOMIC_LOAD_NAND_I32:
|
|
|
|
return EmitAtomicBinary(MI, BB, 4, 0, true);
|
|
|
|
|
|
|
|
case Mips::ATOMIC_LOAD_SUB_I8:
|
|
|
|
return EmitAtomicBinaryPartword(MI, BB, 1, Mips::SUBu);
|
|
|
|
case Mips::ATOMIC_LOAD_SUB_I16:
|
|
|
|
return EmitAtomicBinaryPartword(MI, BB, 2, Mips::SUBu);
|
|
|
|
case Mips::ATOMIC_LOAD_SUB_I32:
|
|
|
|
return EmitAtomicBinary(MI, BB, 4, Mips::SUBu);
|
|
|
|
|
|
|
|
case Mips::ATOMIC_SWAP_I8:
|
|
|
|
return EmitAtomicBinaryPartword(MI, BB, 1, 0);
|
|
|
|
case Mips::ATOMIC_SWAP_I16:
|
|
|
|
return EmitAtomicBinaryPartword(MI, BB, 2, 0);
|
|
|
|
case Mips::ATOMIC_SWAP_I32:
|
|
|
|
return EmitAtomicBinary(MI, BB, 4, 0);
|
|
|
|
|
|
|
|
case Mips::ATOMIC_CMP_SWAP_I8:
|
|
|
|
return EmitAtomicCmpSwapPartword(MI, BB, 1);
|
|
|
|
case Mips::ATOMIC_CMP_SWAP_I16:
|
|
|
|
return EmitAtomicCmpSwapPartword(MI, BB, 2);
|
|
|
|
case Mips::ATOMIC_CMP_SWAP_I32:
|
|
|
|
return EmitAtomicCmpSwap(MI, BB, 4);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-31 10:54:07 +08:00
|
|
|
// This function also handles Mips::ATOMIC_SWAP_I32 (when BinOpcode == 0), and
|
|
|
|
// Mips::ATOMIC_LOAD_NAND_I32 (when Nand == true)
|
|
|
|
MachineBasicBlock *
|
|
|
|
MipsTargetLowering::EmitAtomicBinary(MachineInstr *MI, MachineBasicBlock *BB,
|
2011-06-09 07:55:35 +08:00
|
|
|
unsigned Size, unsigned BinOpcode,
|
2011-06-08 02:58:42 +08:00
|
|
|
bool Nand) const {
|
2011-05-31 10:54:07 +08:00
|
|
|
assert(Size == 4 && "Unsupported size for EmitAtomicBinary.");
|
|
|
|
|
|
|
|
MachineFunction *MF = BB->getParent();
|
|
|
|
MachineRegisterInfo &RegInfo = MF->getRegInfo();
|
|
|
|
const TargetRegisterClass *RC = getRegClassFor(MVT::i32);
|
|
|
|
const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
|
|
|
|
DebugLoc dl = MI->getDebugLoc();
|
|
|
|
|
|
|
|
unsigned Dest = MI->getOperand(0).getReg();
|
|
|
|
unsigned Ptr = MI->getOperand(1).getReg();
|
|
|
|
unsigned Incr = MI->getOperand(2).getReg();
|
|
|
|
|
|
|
|
unsigned Oldval = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp1 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp2 = RegInfo.createVirtualRegister(RC);
|
|
|
|
|
|
|
|
// insert new blocks after the current block
|
|
|
|
const BasicBlock *LLVM_BB = BB->getBasicBlock();
|
|
|
|
MachineBasicBlock *loopMBB = MF->CreateMachineBasicBlock(LLVM_BB);
|
|
|
|
MachineBasicBlock *exitMBB = MF->CreateMachineBasicBlock(LLVM_BB);
|
|
|
|
MachineFunction::iterator It = BB;
|
|
|
|
++It;
|
|
|
|
MF->insert(It, loopMBB);
|
|
|
|
MF->insert(It, exitMBB);
|
|
|
|
|
|
|
|
// Transfer the remainder of BB and its successor edges to exitMBB.
|
|
|
|
exitMBB->splice(exitMBB->begin(), BB,
|
|
|
|
llvm::next(MachineBasicBlock::iterator(MI)),
|
|
|
|
BB->end());
|
|
|
|
exitMBB->transferSuccessorsAndUpdatePHIs(BB);
|
|
|
|
|
|
|
|
// thisMBB:
|
|
|
|
// ...
|
|
|
|
// sw incr, fi(sp) // store incr to stack (when BinOpcode == 0)
|
|
|
|
// fallthrough --> loopMBB
|
|
|
|
|
|
|
|
// Note: for atomic.swap (when BinOpcode == 0), storing incr to stack before
|
|
|
|
// the loop and then loading it from stack in block loopMBB is necessary to
|
|
|
|
// prevent MachineLICM pass to hoist "or" instruction out of the block
|
|
|
|
// loopMBB.
|
|
|
|
|
2011-06-01 04:25:26 +08:00
|
|
|
int fi = 0;
|
2011-05-31 10:54:07 +08:00
|
|
|
if (BinOpcode == 0 && !Nand) {
|
|
|
|
// Get or create a temporary stack location.
|
|
|
|
MipsFunctionInfo *MipsFI = MF->getInfo<MipsFunctionInfo>();
|
|
|
|
fi = MipsFI->getAtomicFrameIndex();
|
|
|
|
if (fi == -1) {
|
|
|
|
fi = MF->getFrameInfo()->CreateStackObject(Size, Size, false);
|
|
|
|
MipsFI->setAtomicFrameIndex(fi);
|
|
|
|
}
|
|
|
|
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::SW))
|
|
|
|
.addReg(Incr).addImm(0).addFrameIndex(fi);
|
|
|
|
}
|
|
|
|
BB->addSuccessor(loopMBB);
|
|
|
|
|
|
|
|
// loopMBB:
|
|
|
|
// ll oldval, 0(ptr)
|
|
|
|
// or dest, $0, oldval
|
|
|
|
// <binop> tmp1, oldval, incr
|
|
|
|
// sc tmp1, 0(ptr)
|
|
|
|
// beq tmp1, $0, loopMBB
|
|
|
|
BB = loopMBB;
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::LL), Oldval).addImm(0).addReg(Ptr);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::OR), Dest).addReg(Mips::ZERO).addReg(Oldval);
|
|
|
|
if (Nand) {
|
|
|
|
// and tmp2, oldval, incr
|
|
|
|
// nor tmp1, $0, tmp2
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::AND), Tmp2).addReg(Oldval).addReg(Incr);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::NOR), Tmp1).addReg(Mips::ZERO).addReg(Tmp2);
|
|
|
|
} else if (BinOpcode) {
|
|
|
|
// <binop> tmp1, oldval, incr
|
|
|
|
BuildMI(BB, dl, TII->get(BinOpcode), Tmp1).addReg(Oldval).addReg(Incr);
|
|
|
|
} else {
|
|
|
|
// lw tmp2, fi(sp) // load incr from stack
|
|
|
|
// or tmp1, $zero, tmp2
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::LW), Tmp2).addImm(0).addFrameIndex(fi);;
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::OR), Tmp1).addReg(Mips::ZERO).addReg(Tmp2);
|
|
|
|
}
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::SC), Tmp1).addReg(Tmp1).addImm(0).addReg(Ptr);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::BEQ))
|
|
|
|
.addReg(Tmp1).addReg(Mips::ZERO).addMBB(loopMBB);
|
|
|
|
BB->addSuccessor(loopMBB);
|
|
|
|
BB->addSuccessor(exitMBB);
|
|
|
|
|
|
|
|
MI->eraseFromParent(); // The instruction is gone now.
|
|
|
|
|
|
|
|
return BB;
|
|
|
|
}
|
|
|
|
|
|
|
|
MachineBasicBlock *
|
|
|
|
MipsTargetLowering::EmitAtomicBinaryPartword(MachineInstr *MI,
|
2011-06-08 02:58:42 +08:00
|
|
|
MachineBasicBlock *BB,
|
|
|
|
unsigned Size, unsigned BinOpcode,
|
|
|
|
bool Nand) const {
|
2011-05-31 10:54:07 +08:00
|
|
|
assert((Size == 1 || Size == 2) &&
|
|
|
|
"Unsupported size for EmitAtomicBinaryPartial.");
|
|
|
|
|
|
|
|
MachineFunction *MF = BB->getParent();
|
|
|
|
MachineRegisterInfo &RegInfo = MF->getRegInfo();
|
|
|
|
const TargetRegisterClass *RC = getRegClassFor(MVT::i32);
|
|
|
|
const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
|
|
|
|
DebugLoc dl = MI->getDebugLoc();
|
|
|
|
|
|
|
|
unsigned Dest = MI->getOperand(0).getReg();
|
|
|
|
unsigned Ptr = MI->getOperand(1).getReg();
|
|
|
|
unsigned Incr = MI->getOperand(2).getReg();
|
|
|
|
|
|
|
|
unsigned Addr = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Shift = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Mask = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Mask2 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Newval = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Oldval = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Incr2 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp1 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp2 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp3 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp4 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp5 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp6 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp7 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp8 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp9 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp10 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp11 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp12 = RegInfo.createVirtualRegister(RC);
|
|
|
|
|
|
|
|
// insert new blocks after the current block
|
|
|
|
const BasicBlock *LLVM_BB = BB->getBasicBlock();
|
|
|
|
MachineBasicBlock *loopMBB = MF->CreateMachineBasicBlock(LLVM_BB);
|
|
|
|
MachineBasicBlock *exitMBB = MF->CreateMachineBasicBlock(LLVM_BB);
|
|
|
|
MachineFunction::iterator It = BB;
|
|
|
|
++It;
|
|
|
|
MF->insert(It, loopMBB);
|
|
|
|
MF->insert(It, exitMBB);
|
|
|
|
|
|
|
|
// Transfer the remainder of BB and its successor edges to exitMBB.
|
|
|
|
exitMBB->splice(exitMBB->begin(), BB,
|
|
|
|
llvm::next(MachineBasicBlock::iterator(MI)),
|
|
|
|
BB->end());
|
|
|
|
exitMBB->transferSuccessorsAndUpdatePHIs(BB);
|
|
|
|
|
|
|
|
// thisMBB:
|
|
|
|
// addiu tmp1,$0,-4 # 0xfffffffc
|
|
|
|
// and addr,ptr,tmp1
|
|
|
|
// andi tmp2,ptr,3
|
|
|
|
// sll shift,tmp2,3
|
|
|
|
// ori tmp3,$0,255 # 0xff
|
|
|
|
// sll mask,tmp3,shift
|
|
|
|
// nor mask2,$0,mask
|
|
|
|
// andi tmp4,incr,255
|
|
|
|
// sll incr2,tmp4,shift
|
|
|
|
// sw incr2, fi(sp) // store incr2 to stack (when BinOpcode == 0)
|
|
|
|
|
|
|
|
// Note: for atomic.swap (when BinOpcode == 0), storing incr2 to stack before
|
|
|
|
// the loop and then loading it from stack in block loopMBB is necessary to
|
|
|
|
// prevent MachineLICM pass to hoist "or" instruction out of the block
|
|
|
|
// loopMBB.
|
|
|
|
|
|
|
|
int64_t MaskImm = (Size == 1) ? 255 : 65535;
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::ADDiu), Tmp1).addReg(Mips::ZERO).addImm(-4);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::AND), Addr).addReg(Ptr).addReg(Tmp1);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::ANDi), Tmp2).addReg(Ptr).addImm(3);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::SLL), Shift).addReg(Tmp2).addImm(3);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::ORi), Tmp3).addReg(Mips::ZERO).addImm(MaskImm);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::SLL), Mask).addReg(Tmp3).addReg(Shift);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::NOR), Mask2).addReg(Mips::ZERO).addReg(Mask);
|
|
|
|
if (BinOpcode != Mips::SUBu) {
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::ANDi), Tmp4).addReg(Incr).addImm(MaskImm);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::SLL), Incr2).addReg(Tmp4).addReg(Shift);
|
|
|
|
} else {
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::SUBu), Tmp4).addReg(Mips::ZERO).addReg(Incr);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::ANDi), Tmp5).addReg(Tmp4).addImm(MaskImm);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::SLL), Incr2).addReg(Tmp5).addReg(Shift);
|
|
|
|
}
|
2011-06-01 04:25:26 +08:00
|
|
|
|
|
|
|
int fi = 0;
|
2011-05-31 10:54:07 +08:00
|
|
|
if (BinOpcode == 0 && !Nand) {
|
|
|
|
// Get or create a temporary stack location.
|
|
|
|
MipsFunctionInfo *MipsFI = MF->getInfo<MipsFunctionInfo>();
|
|
|
|
fi = MipsFI->getAtomicFrameIndex();
|
|
|
|
if (fi == -1) {
|
|
|
|
fi = MF->getFrameInfo()->CreateStackObject(Size, Size, false);
|
|
|
|
MipsFI->setAtomicFrameIndex(fi);
|
|
|
|
}
|
|
|
|
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::SW))
|
|
|
|
.addReg(Incr2).addImm(0).addFrameIndex(fi);
|
|
|
|
}
|
|
|
|
BB->addSuccessor(loopMBB);
|
|
|
|
|
|
|
|
// loopMBB:
|
|
|
|
// ll oldval,0(addr)
|
|
|
|
// binop tmp7,oldval,incr2
|
|
|
|
// and newval,tmp7,mask
|
|
|
|
// and tmp8,oldval,mask2
|
|
|
|
// or tmp9,tmp8,newval
|
|
|
|
// sc tmp9,0(addr)
|
|
|
|
// beq tmp9,$0,loopMBB
|
|
|
|
BB = loopMBB;
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::LL), Oldval).addImm(0).addReg(Addr);
|
|
|
|
if (Nand) {
|
|
|
|
// and tmp6, oldval, incr2
|
|
|
|
// nor tmp7, $0, tmp6
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::AND), Tmp6).addReg(Oldval).addReg(Incr2);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::NOR), Tmp7).addReg(Mips::ZERO).addReg(Tmp6);
|
|
|
|
} else if (BinOpcode == Mips::SUBu) {
|
|
|
|
// addu tmp7, oldval, incr2
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::ADDu), Tmp7).addReg(Oldval).addReg(Incr2);
|
|
|
|
} else if (BinOpcode) {
|
|
|
|
// <binop> tmp7, oldval, incr2
|
|
|
|
BuildMI(BB, dl, TII->get(BinOpcode), Tmp7).addReg(Oldval).addReg(Incr2);
|
|
|
|
} else {
|
|
|
|
// lw tmp6, fi(sp) // load incr2 from stack
|
|
|
|
// or tmp7, $zero, tmp6
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::LW), Tmp6).addImm(0).addFrameIndex(fi);;
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::OR), Tmp7).addReg(Mips::ZERO).addReg(Tmp6);
|
|
|
|
}
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::AND), Newval).addReg(Tmp7).addReg(Mask);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::AND), Tmp8).addReg(Oldval).addReg(Mask2);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::OR), Tmp9).addReg(Tmp8).addReg(Newval);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::SC), Tmp9).addReg(Tmp9).addImm(0).addReg(Addr);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::BEQ))
|
|
|
|
.addReg(Tmp9).addReg(Mips::ZERO).addMBB(loopMBB);
|
|
|
|
BB->addSuccessor(loopMBB);
|
|
|
|
BB->addSuccessor(exitMBB);
|
|
|
|
|
|
|
|
// exitMBB:
|
|
|
|
// and tmp10,oldval,mask
|
|
|
|
// srl tmp11,tmp10,shift
|
|
|
|
// sll tmp12,tmp11,24
|
|
|
|
// sra dest,tmp12,24
|
|
|
|
BB = exitMBB;
|
|
|
|
int64_t ShiftImm = (Size == 1) ? 24 : 16;
|
|
|
|
// reverse order
|
|
|
|
BuildMI(*BB, BB->begin(), dl, TII->get(Mips::SRA), Dest)
|
|
|
|
.addReg(Tmp12).addImm(ShiftImm);
|
|
|
|
BuildMI(*BB, BB->begin(), dl, TII->get(Mips::SLL), Tmp12)
|
|
|
|
.addReg(Tmp11).addImm(ShiftImm);
|
|
|
|
BuildMI(*BB, BB->begin(), dl, TII->get(Mips::SRL), Tmp11)
|
|
|
|
.addReg(Tmp10).addReg(Shift);
|
|
|
|
BuildMI(*BB, BB->begin(), dl, TII->get(Mips::AND), Tmp10)
|
|
|
|
.addReg(Oldval).addReg(Mask);
|
|
|
|
|
|
|
|
MI->eraseFromParent(); // The instruction is gone now.
|
|
|
|
|
|
|
|
return BB;
|
|
|
|
}
|
|
|
|
|
|
|
|
MachineBasicBlock *
|
|
|
|
MipsTargetLowering::EmitAtomicCmpSwap(MachineInstr *MI,
|
2011-06-08 02:58:42 +08:00
|
|
|
MachineBasicBlock *BB,
|
|
|
|
unsigned Size) const {
|
2011-05-31 10:54:07 +08:00
|
|
|
assert(Size == 4 && "Unsupported size for EmitAtomicCmpSwap.");
|
|
|
|
|
|
|
|
MachineFunction *MF = BB->getParent();
|
|
|
|
MachineRegisterInfo &RegInfo = MF->getRegInfo();
|
|
|
|
const TargetRegisterClass *RC = getRegClassFor(MVT::i32);
|
|
|
|
const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
|
|
|
|
DebugLoc dl = MI->getDebugLoc();
|
|
|
|
|
|
|
|
unsigned Dest = MI->getOperand(0).getReg();
|
|
|
|
unsigned Ptr = MI->getOperand(1).getReg();
|
|
|
|
unsigned Oldval = MI->getOperand(2).getReg();
|
|
|
|
unsigned Newval = MI->getOperand(3).getReg();
|
|
|
|
|
|
|
|
unsigned Tmp1 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp2 = RegInfo.createVirtualRegister(RC);
|
|
|
|
|
|
|
|
// insert new blocks after the current block
|
|
|
|
const BasicBlock *LLVM_BB = BB->getBasicBlock();
|
|
|
|
MachineBasicBlock *loop1MBB = MF->CreateMachineBasicBlock(LLVM_BB);
|
|
|
|
MachineBasicBlock *loop2MBB = MF->CreateMachineBasicBlock(LLVM_BB);
|
|
|
|
MachineBasicBlock *exitMBB = MF->CreateMachineBasicBlock(LLVM_BB);
|
|
|
|
MachineFunction::iterator It = BB;
|
|
|
|
++It;
|
|
|
|
MF->insert(It, loop1MBB);
|
|
|
|
MF->insert(It, loop2MBB);
|
|
|
|
MF->insert(It, exitMBB);
|
|
|
|
|
|
|
|
// Transfer the remainder of BB and its successor edges to exitMBB.
|
|
|
|
exitMBB->splice(exitMBB->begin(), BB,
|
|
|
|
llvm::next(MachineBasicBlock::iterator(MI)),
|
|
|
|
BB->end());
|
|
|
|
exitMBB->transferSuccessorsAndUpdatePHIs(BB);
|
|
|
|
|
|
|
|
// Get or create a temporary stack location.
|
|
|
|
MipsFunctionInfo *MipsFI = MF->getInfo<MipsFunctionInfo>();
|
|
|
|
int fi = MipsFI->getAtomicFrameIndex();
|
|
|
|
if (fi == -1) {
|
|
|
|
fi = MF->getFrameInfo()->CreateStackObject(Size, Size, false);
|
|
|
|
MipsFI->setAtomicFrameIndex(fi);
|
|
|
|
}
|
|
|
|
|
|
|
|
// thisMBB:
|
|
|
|
// ...
|
|
|
|
// sw newval, fi(sp) // store newval to stack
|
|
|
|
// fallthrough --> loop1MBB
|
|
|
|
|
|
|
|
// Note: storing newval to stack before the loop and then loading it from
|
|
|
|
// stack in block loop2MBB is necessary to prevent MachineLICM pass to
|
|
|
|
// hoist "or" instruction out of the block loop2MBB.
|
|
|
|
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::SW))
|
|
|
|
.addReg(Newval).addImm(0).addFrameIndex(fi);
|
|
|
|
BB->addSuccessor(loop1MBB);
|
|
|
|
|
|
|
|
// loop1MBB:
|
|
|
|
// ll dest, 0(ptr)
|
|
|
|
// bne dest, oldval, exitMBB
|
|
|
|
BB = loop1MBB;
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::LL), Dest).addImm(0).addReg(Ptr);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::BNE))
|
|
|
|
.addReg(Dest).addReg(Oldval).addMBB(exitMBB);
|
|
|
|
BB->addSuccessor(exitMBB);
|
|
|
|
BB->addSuccessor(loop2MBB);
|
|
|
|
|
|
|
|
// loop2MBB:
|
|
|
|
// lw tmp2, fi(sp) // load newval from stack
|
|
|
|
// or tmp1, $0, tmp2
|
|
|
|
// sc tmp1, 0(ptr)
|
|
|
|
// beq tmp1, $0, loop1MBB
|
|
|
|
BB = loop2MBB;
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::LW), Tmp2).addImm(0).addFrameIndex(fi);;
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::OR), Tmp1).addReg(Mips::ZERO).addReg(Tmp2);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::SC), Tmp1).addReg(Tmp1).addImm(0).addReg(Ptr);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::BEQ))
|
|
|
|
.addReg(Tmp1).addReg(Mips::ZERO).addMBB(loop1MBB);
|
|
|
|
BB->addSuccessor(loop1MBB);
|
|
|
|
BB->addSuccessor(exitMBB);
|
|
|
|
|
|
|
|
MI->eraseFromParent(); // The instruction is gone now.
|
|
|
|
|
|
|
|
return BB;
|
|
|
|
}
|
|
|
|
|
|
|
|
MachineBasicBlock *
|
|
|
|
MipsTargetLowering::EmitAtomicCmpSwapPartword(MachineInstr *MI,
|
2011-06-08 02:58:42 +08:00
|
|
|
MachineBasicBlock *BB,
|
|
|
|
unsigned Size) const {
|
2011-05-31 10:54:07 +08:00
|
|
|
assert((Size == 1 || Size == 2) &&
|
|
|
|
"Unsupported size for EmitAtomicCmpSwapPartial.");
|
|
|
|
|
|
|
|
MachineFunction *MF = BB->getParent();
|
|
|
|
MachineRegisterInfo &RegInfo = MF->getRegInfo();
|
|
|
|
const TargetRegisterClass *RC = getRegClassFor(MVT::i32);
|
|
|
|
const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
|
|
|
|
DebugLoc dl = MI->getDebugLoc();
|
|
|
|
|
|
|
|
unsigned Dest = MI->getOperand(0).getReg();
|
|
|
|
unsigned Ptr = MI->getOperand(1).getReg();
|
|
|
|
unsigned Oldval = MI->getOperand(2).getReg();
|
|
|
|
unsigned Newval = MI->getOperand(3).getReg();
|
|
|
|
|
|
|
|
unsigned Addr = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Shift = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Mask = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Mask2 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Oldval2 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Oldval3 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Oldval4 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Newval2 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp1 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp2 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp3 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp4 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp5 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp6 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp7 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp8 = RegInfo.createVirtualRegister(RC);
|
|
|
|
unsigned Tmp9 = RegInfo.createVirtualRegister(RC);
|
|
|
|
|
|
|
|
// insert new blocks after the current block
|
|
|
|
const BasicBlock *LLVM_BB = BB->getBasicBlock();
|
|
|
|
MachineBasicBlock *loop1MBB = MF->CreateMachineBasicBlock(LLVM_BB);
|
|
|
|
MachineBasicBlock *loop2MBB = MF->CreateMachineBasicBlock(LLVM_BB);
|
|
|
|
MachineBasicBlock *exitMBB = MF->CreateMachineBasicBlock(LLVM_BB);
|
|
|
|
MachineFunction::iterator It = BB;
|
|
|
|
++It;
|
|
|
|
MF->insert(It, loop1MBB);
|
|
|
|
MF->insert(It, loop2MBB);
|
|
|
|
MF->insert(It, exitMBB);
|
|
|
|
|
|
|
|
// Transfer the remainder of BB and its successor edges to exitMBB.
|
|
|
|
exitMBB->splice(exitMBB->begin(), BB,
|
|
|
|
llvm::next(MachineBasicBlock::iterator(MI)),
|
|
|
|
BB->end());
|
|
|
|
exitMBB->transferSuccessorsAndUpdatePHIs(BB);
|
|
|
|
|
|
|
|
// thisMBB:
|
|
|
|
// addiu tmp1,$0,-4 # 0xfffffffc
|
|
|
|
// and addr,ptr,tmp1
|
|
|
|
// andi tmp2,ptr,3
|
|
|
|
// sll shift,tmp2,3
|
|
|
|
// ori tmp3,$0,255 # 0xff
|
|
|
|
// sll mask,tmp3,shift
|
|
|
|
// nor mask2,$0,mask
|
|
|
|
// andi tmp4,oldval,255
|
|
|
|
// sll oldval2,tmp4,shift
|
|
|
|
// andi tmp5,newval,255
|
|
|
|
// sll newval2,tmp5,shift
|
|
|
|
int64_t MaskImm = (Size == 1) ? 255 : 65535;
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::ADDiu), Tmp1).addReg(Mips::ZERO).addImm(-4);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::AND), Addr).addReg(Ptr).addReg(Tmp1);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::ANDi), Tmp2).addReg(Ptr).addImm(3);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::SLL), Shift).addReg(Tmp2).addImm(3);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::ORi), Tmp3).addReg(Mips::ZERO).addImm(MaskImm);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::SLL), Mask).addReg(Tmp3).addReg(Shift);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::NOR), Mask2).addReg(Mips::ZERO).addReg(Mask);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::ANDi), Tmp4).addReg(Oldval).addImm(MaskImm);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::SLL), Oldval2).addReg(Tmp4).addReg(Shift);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::ANDi), Tmp5).addReg(Newval).addImm(MaskImm);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::SLL), Newval2).addReg(Tmp5).addReg(Shift);
|
|
|
|
BB->addSuccessor(loop1MBB);
|
|
|
|
|
|
|
|
// loop1MBB:
|
|
|
|
// ll oldval3,0(addr)
|
|
|
|
// and oldval4,oldval3,mask
|
|
|
|
// bne oldval4,oldval2,exitMBB
|
|
|
|
BB = loop1MBB;
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::LL), Oldval3).addImm(0).addReg(Addr);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::AND), Oldval4).addReg(Oldval3).addReg(Mask);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::BNE))
|
|
|
|
.addReg(Oldval4).addReg(Oldval2).addMBB(exitMBB);
|
|
|
|
BB->addSuccessor(exitMBB);
|
|
|
|
BB->addSuccessor(loop2MBB);
|
|
|
|
|
|
|
|
// loop2MBB:
|
|
|
|
// and tmp6,oldval3,mask2
|
|
|
|
// or tmp7,tmp6,newval2
|
|
|
|
// sc tmp7,0(addr)
|
|
|
|
// beq tmp7,$0,loop1MBB
|
|
|
|
BB = loop2MBB;
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::AND), Tmp6).addReg(Oldval3).addReg(Mask2);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::OR), Tmp7).addReg(Tmp6).addReg(Newval2);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::SC), Tmp7)
|
|
|
|
.addReg(Tmp7).addImm(0).addReg(Addr);
|
|
|
|
BuildMI(BB, dl, TII->get(Mips::BEQ))
|
|
|
|
.addReg(Tmp7).addReg(Mips::ZERO).addMBB(loop1MBB);
|
|
|
|
BB->addSuccessor(loop1MBB);
|
|
|
|
BB->addSuccessor(exitMBB);
|
|
|
|
|
|
|
|
// exitMBB:
|
|
|
|
// srl tmp8,oldval4,shift
|
|
|
|
// sll tmp9,tmp8,24
|
|
|
|
// sra dest,tmp9,24
|
|
|
|
BB = exitMBB;
|
|
|
|
int64_t ShiftImm = (Size == 1) ? 24 : 16;
|
|
|
|
// reverse order
|
|
|
|
BuildMI(*BB, BB->begin(), dl, TII->get(Mips::SRA), Dest)
|
|
|
|
.addReg(Tmp9).addImm(ShiftImm);
|
|
|
|
BuildMI(*BB, BB->begin(), dl, TII->get(Mips::SLL), Tmp9)
|
|
|
|
.addReg(Tmp8).addImm(ShiftImm);
|
|
|
|
BuildMI(*BB, BB->begin(), dl, TII->get(Mips::SRL), Tmp8)
|
|
|
|
.addReg(Oldval4).addReg(Shift);
|
|
|
|
|
|
|
|
MI->eraseFromParent(); // The instruction is gone now.
|
|
|
|
|
|
|
|
return BB;
|
|
|
|
}
|
|
|
|
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-06-06 15:42:06 +08:00
|
|
|
// Misc Lower Operation implementation
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2008-08-08 03:08:11 +08:00
|
|
|
SDValue MipsTargetLowering::
|
2010-04-17 23:26:15 +08:00
|
|
|
LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const
|
2008-08-08 03:08:11 +08:00
|
|
|
{
|
2011-06-21 08:40:49 +08:00
|
|
|
MachineFunction &MF = DAG.getMachineFunction();
|
|
|
|
MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
|
|
|
|
|
|
|
|
assert(getTargetMachine().getFrameLowering()->getStackAlignment() >=
|
2011-05-25 10:20:00 +08:00
|
|
|
cast<ConstantSDNode>(Op.getOperand(2).getNode())->getZExtValue() &&
|
|
|
|
"Cannot lower if the alignment of the allocated space is larger than \
|
|
|
|
that of the stack.");
|
|
|
|
|
2008-08-08 03:08:11 +08:00
|
|
|
SDValue Chain = Op.getOperand(0);
|
|
|
|
SDValue Size = Op.getOperand(1);
|
2009-02-05 07:02:30 +08:00
|
|
|
DebugLoc dl = Op.getDebugLoc();
|
2008-08-08 03:08:11 +08:00
|
|
|
|
|
|
|
// Get a reference from Mips stack pointer
|
2009-08-12 04:47:22 +08:00
|
|
|
SDValue StackPointer = DAG.getCopyFromReg(Chain, dl, Mips::SP, MVT::i32);
|
2008-08-08 03:08:11 +08:00
|
|
|
|
|
|
|
// Subtract the dynamic size from the actual stack size to
|
|
|
|
// obtain the new stack size.
|
2009-08-12 04:47:22 +08:00
|
|
|
SDValue Sub = DAG.getNode(ISD::SUB, dl, MVT::i32, StackPointer, Size);
|
2008-08-08 03:08:11 +08:00
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
// The Sub result contains the new stack start address, so it
|
2008-08-08 03:08:11 +08:00
|
|
|
// must be placed in the stack pointer register.
|
2011-05-25 10:20:00 +08:00
|
|
|
Chain = DAG.getCopyToReg(StackPointer.getValue(1), dl, Mips::SP, Sub,
|
|
|
|
SDValue());
|
2010-11-23 11:31:01 +08:00
|
|
|
|
|
|
|
// This node always has two return values: a new stack pointer
|
2008-08-08 03:08:11 +08:00
|
|
|
// value and a chain
|
2011-06-21 08:40:49 +08:00
|
|
|
SDVTList VTLs = DAG.getVTList(MVT::i32, MVT::Other);
|
|
|
|
SDValue Ptr = DAG.getFrameIndex(MipsFI->getDynAllocFI(), getPointerTy());
|
|
|
|
SDValue Ops[] = { Chain, Ptr, Chain.getValue(1) };
|
|
|
|
|
|
|
|
return DAG.getNode(MipsISD::DynAlloc, dl, VTLs, Ops, 3);
|
2008-08-08 03:08:11 +08:00
|
|
|
}
|
|
|
|
|
2008-07-29 03:11:24 +08:00
|
|
|
SDValue MipsTargetLowering::
|
2010-04-17 23:26:15 +08:00
|
|
|
LowerBRCOND(SDValue Op, SelectionDAG &DAG) const
|
2008-07-29 03:11:24 +08:00
|
|
|
{
|
2010-11-23 11:31:01 +08:00
|
|
|
// The first operand is the chain, the second is the condition, the third is
|
2008-07-29 03:11:24 +08:00
|
|
|
// the block to branch to if the condition is true.
|
|
|
|
SDValue Chain = Op.getOperand(0);
|
|
|
|
SDValue Dest = Op.getOperand(2);
|
2009-02-07 05:50:26 +08:00
|
|
|
DebugLoc dl = Op.getDebugLoc();
|
2008-08-01 02:31:28 +08:00
|
|
|
|
2011-04-01 02:26:17 +08:00
|
|
|
SDValue CondRes = CreateFPCmp(DAG, Op.getOperand(1));
|
|
|
|
|
2011-04-15 13:18:47 +08:00
|
|
|
// Return if flag is not set by a floating point comparison.
|
2011-04-01 02:26:17 +08:00
|
|
|
if (CondRes.getOpcode() != MipsISD::FPCmp)
|
2008-07-31 01:06:13 +08:00
|
|
|
return Op;
|
2010-11-23 11:31:01 +08:00
|
|
|
|
2008-08-01 02:31:28 +08:00
|
|
|
SDValue CCNode = CondRes.getOperand(2);
|
2008-09-13 00:56:44 +08:00
|
|
|
Mips::CondCode CC =
|
|
|
|
(Mips::CondCode)cast<ConstantSDNode>(CCNode)->getZExtValue();
|
2010-11-23 11:31:01 +08:00
|
|
|
SDValue BrCode = DAG.getConstant(GetFPBranchCodeFromCond(CC), MVT::i32);
|
2008-07-29 03:11:24 +08:00
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
return DAG.getNode(MipsISD::FPBrcond, dl, Op.getValueType(), Chain, BrCode,
|
2011-04-01 02:26:17 +08:00
|
|
|
Dest, CondRes);
|
2008-07-29 03:11:24 +08:00
|
|
|
}
|
|
|
|
|
2008-07-30 03:05:28 +08:00
|
|
|
SDValue MipsTargetLowering::
|
2010-04-17 23:26:15 +08:00
|
|
|
LowerSELECT(SDValue Op, SelectionDAG &DAG) const
|
2008-07-30 03:05:28 +08:00
|
|
|
{
|
2011-04-01 02:26:17 +08:00
|
|
|
SDValue Cond = CreateFPCmp(DAG, Op.getOperand(0));
|
2008-07-30 03:05:28 +08:00
|
|
|
|
2011-04-15 13:18:47 +08:00
|
|
|
// Return if flag is not set by a floating point comparison.
|
2011-04-01 02:26:17 +08:00
|
|
|
if (Cond.getOpcode() != MipsISD::FPCmp)
|
|
|
|
return Op;
|
2008-08-13 15:13:40 +08:00
|
|
|
|
2011-04-01 02:26:17 +08:00
|
|
|
return CreateCMovFP(DAG, Cond, Op.getOperand(1), Op.getOperand(2),
|
|
|
|
Op.getDebugLoc());
|
2008-07-30 03:05:28 +08:00
|
|
|
}
|
|
|
|
|
2010-04-17 23:26:15 +08:00
|
|
|
SDValue MipsTargetLowering::LowerGlobalAddress(SDValue Op,
|
|
|
|
SelectionDAG &DAG) const {
|
2009-02-07 05:50:26 +08:00
|
|
|
// FIXME there isn't actually debug info here
|
2009-02-05 04:06:27 +08:00
|
|
|
DebugLoc dl = Op.getDebugLoc();
|
2010-04-15 09:51:59 +08:00
|
|
|
const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
|
2008-07-30 03:29:50 +08:00
|
|
|
|
2009-08-03 10:22:28 +08:00
|
|
|
if (getTargetMachine().getRelocationModel() != Reloc::PIC_) {
|
2009-08-13 13:41:27 +08:00
|
|
|
SDVTList VTs = DAG.getVTList(MVT::i32);
|
2010-11-23 11:31:01 +08:00
|
|
|
|
2009-08-13 14:28:06 +08:00
|
|
|
MipsTargetObjectFile &TLOF = (MipsTargetObjectFile&)getObjFileLowering();
|
2010-11-23 11:31:01 +08:00
|
|
|
|
2009-08-13 13:41:27 +08:00
|
|
|
// %gp_rel relocation
|
2010-11-23 11:31:01 +08:00
|
|
|
if (TLOF.IsGlobalInSmallSection(GV, getTargetMachine())) {
|
|
|
|
SDValue GA = DAG.getTargetGlobalAddress(GV, dl, MVT::i32, 0,
|
2009-09-02 01:27:58 +08:00
|
|
|
MipsII::MO_GPREL);
|
2009-08-13 13:41:27 +08:00
|
|
|
SDValue GPRelNode = DAG.getNode(MipsISD::GPRel, dl, VTs, &GA, 1);
|
|
|
|
SDValue GOT = DAG.getGLOBAL_OFFSET_TABLE(MVT::i32);
|
2010-11-23 11:31:01 +08:00
|
|
|
return DAG.getNode(ISD::ADD, dl, MVT::i32, GOT, GPRelNode);
|
2009-08-13 13:41:27 +08:00
|
|
|
}
|
2008-07-30 03:29:50 +08:00
|
|
|
// %hi/%lo relocation
|
2011-04-02 05:41:06 +08:00
|
|
|
SDValue GAHi = DAG.getTargetGlobalAddress(GV, dl, MVT::i32, 0,
|
|
|
|
MipsII::MO_ABS_HI);
|
|
|
|
SDValue GALo = DAG.getTargetGlobalAddress(GV, dl, MVT::i32, 0,
|
|
|
|
MipsII::MO_ABS_LO);
|
|
|
|
SDValue HiPart = DAG.getNode(MipsISD::Hi, dl, VTs, &GAHi, 1);
|
|
|
|
SDValue Lo = DAG.getNode(MipsISD::Lo, dl, MVT::i32, GALo);
|
2009-08-12 04:47:22 +08:00
|
|
|
return DAG.getNode(ISD::ADD, dl, MVT::i32, HiPart, Lo);
|
2008-07-30 03:29:50 +08:00
|
|
|
}
|
|
|
|
|
2011-06-08 02:58:42 +08:00
|
|
|
SDValue GA = DAG.getTargetGlobalAddress(GV, dl, MVT::i32, 0,
|
|
|
|
MipsII::MO_GOT);
|
|
|
|
GA = DAG.getNode(MipsISD::WrapperPIC, dl, MVT::i32, GA);
|
|
|
|
SDValue ResNode = DAG.getLoad(MVT::i32, dl,
|
|
|
|
DAG.getEntryNode(), GA, MachinePointerInfo(),
|
|
|
|
false, false, 0);
|
|
|
|
// On functions and global targets not internal linked only
|
|
|
|
// a load from got/GP is necessary for PIC to work.
|
|
|
|
if (!GV->hasInternalLinkage() &&
|
|
|
|
(!GV->hasLocalLinkage() || isa<Function>(GV)))
|
|
|
|
return ResNode;
|
|
|
|
SDValue GALo = DAG.getTargetGlobalAddress(GV, dl, MVT::i32, 0,
|
|
|
|
MipsII::MO_ABS_LO);
|
|
|
|
SDValue Lo = DAG.getNode(MipsISD::Lo, dl, MVT::i32, GALo);
|
|
|
|
return DAG.getNode(ISD::ADD, dl, MVT::i32, ResNode, Lo);
|
2008-07-30 03:29:50 +08:00
|
|
|
}
|
|
|
|
|
2011-03-05 04:01:52 +08:00
|
|
|
SDValue MipsTargetLowering::LowerBlockAddress(SDValue Op,
|
|
|
|
SelectionDAG &DAG) const {
|
2011-04-26 01:10:45 +08:00
|
|
|
const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
|
|
|
|
// FIXME there isn't actually debug info here
|
|
|
|
DebugLoc dl = Op.getDebugLoc();
|
|
|
|
|
2011-03-05 04:01:52 +08:00
|
|
|
if (getTargetMachine().getRelocationModel() != Reloc::PIC_) {
|
2011-04-26 01:10:45 +08:00
|
|
|
// %hi/%lo relocation
|
|
|
|
SDValue BAHi = DAG.getBlockAddress(BA, MVT::i32, true,
|
|
|
|
MipsII::MO_ABS_HI);
|
|
|
|
SDValue BALo = DAG.getBlockAddress(BA, MVT::i32, true,
|
|
|
|
MipsII::MO_ABS_LO);
|
|
|
|
SDValue Hi = DAG.getNode(MipsISD::Hi, dl, MVT::i32, BAHi);
|
|
|
|
SDValue Lo = DAG.getNode(MipsISD::Lo, dl, MVT::i32, BALo);
|
|
|
|
return DAG.getNode(ISD::ADD, dl, MVT::i32, Hi, Lo);
|
2011-03-05 04:01:52 +08:00
|
|
|
}
|
2011-04-26 01:10:45 +08:00
|
|
|
|
|
|
|
SDValue BAGOTOffset = DAG.getBlockAddress(BA, MVT::i32, true,
|
|
|
|
MipsII::MO_GOT);
|
2011-05-28 09:07:07 +08:00
|
|
|
BAGOTOffset = DAG.getNode(MipsISD::WrapperPIC, dl, MVT::i32, BAGOTOffset);
|
2011-04-26 01:10:45 +08:00
|
|
|
SDValue BALOOffset = DAG.getBlockAddress(BA, MVT::i32, true,
|
|
|
|
MipsII::MO_ABS_LO);
|
|
|
|
SDValue Load = DAG.getLoad(MVT::i32, dl,
|
|
|
|
DAG.getEntryNode(), BAGOTOffset,
|
|
|
|
MachinePointerInfo(), false, false, 0);
|
|
|
|
SDValue Lo = DAG.getNode(MipsISD::Lo, dl, MVT::i32, BALOOffset);
|
|
|
|
return DAG.getNode(ISD::ADD, dl, MVT::i32, Load, Lo);
|
2011-03-05 04:01:52 +08:00
|
|
|
}
|
|
|
|
|
2008-07-30 03:29:50 +08:00
|
|
|
SDValue MipsTargetLowering::
|
2010-04-17 23:26:15 +08:00
|
|
|
LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const
|
2008-07-30 03:29:50 +08:00
|
|
|
{
|
2011-05-31 10:53:58 +08:00
|
|
|
// If the relocation model is PIC, use the General Dynamic TLS Model,
|
|
|
|
// otherwise use the Initial Exec or Local Exec TLS Model.
|
|
|
|
// TODO: implement Local Dynamic TLS model
|
|
|
|
|
|
|
|
GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
|
|
|
|
DebugLoc dl = GA->getDebugLoc();
|
|
|
|
const GlobalValue *GV = GA->getGlobal();
|
|
|
|
EVT PtrVT = getPointerTy();
|
|
|
|
|
|
|
|
if (getTargetMachine().getRelocationModel() == Reloc::PIC_) {
|
|
|
|
// General Dynamic TLS Model
|
|
|
|
SDValue TGA = DAG.getTargetGlobalAddress(GV, dl, MVT::i32,
|
2011-06-21 09:02:03 +08:00
|
|
|
0, MipsII::MO_TLSGD);
|
2011-05-31 10:53:58 +08:00
|
|
|
SDValue Tlsgd = DAG.getNode(MipsISD::TlsGd, dl, MVT::i32, TGA);
|
|
|
|
SDValue GP = DAG.getRegister(Mips::GP, MVT::i32);
|
|
|
|
SDValue Argument = DAG.getNode(ISD::ADD, dl, MVT::i32, GP, Tlsgd);
|
|
|
|
|
|
|
|
ArgListTy Args;
|
|
|
|
ArgListEntry Entry;
|
|
|
|
Entry.Node = Argument;
|
|
|
|
Entry.Ty = (const Type *) Type::getInt32Ty(*DAG.getContext());
|
|
|
|
Args.push_back(Entry);
|
|
|
|
std::pair<SDValue, SDValue> CallResult =
|
|
|
|
LowerCallTo(DAG.getEntryNode(),
|
2011-06-21 09:02:03 +08:00
|
|
|
(const Type *) Type::getInt32Ty(*DAG.getContext()),
|
|
|
|
false, false, false, false, 0, CallingConv::C, false, true,
|
|
|
|
DAG.getExternalSymbol("__tls_get_addr", PtrVT), Args, DAG,
|
|
|
|
dl);
|
2011-05-31 10:53:58 +08:00
|
|
|
|
|
|
|
return CallResult.first;
|
2011-06-21 09:02:03 +08:00
|
|
|
}
|
2011-05-31 10:53:58 +08:00
|
|
|
|
2011-06-21 09:02:03 +08:00
|
|
|
SDValue Offset;
|
|
|
|
if (GV->isDeclaration()) {
|
|
|
|
// Initial Exec TLS Model
|
|
|
|
SDValue TGA = DAG.getTargetGlobalAddress(GV, dl, MVT::i32, 0,
|
|
|
|
MipsII::MO_GOTTPREL);
|
|
|
|
Offset = DAG.getLoad(MVT::i32, dl,
|
|
|
|
DAG.getEntryNode(), TGA, MachinePointerInfo(),
|
|
|
|
false, false, 0);
|
|
|
|
} else {
|
|
|
|
// Local Exec TLS Model
|
|
|
|
SDVTList VTs = DAG.getVTList(MVT::i32);
|
|
|
|
SDValue TGAHi = DAG.getTargetGlobalAddress(GV, dl, MVT::i32, 0,
|
|
|
|
MipsII::MO_TPREL_HI);
|
|
|
|
SDValue TGALo = DAG.getTargetGlobalAddress(GV, dl, MVT::i32, 0,
|
|
|
|
MipsII::MO_TPREL_LO);
|
|
|
|
SDValue Hi = DAG.getNode(MipsISD::TprelHi, dl, VTs, &TGAHi, 1);
|
|
|
|
SDValue Lo = DAG.getNode(MipsISD::TprelLo, dl, MVT::i32, TGALo);
|
|
|
|
Offset = DAG.getNode(ISD::ADD, dl, MVT::i32, Hi, Lo);
|
2011-05-31 10:53:58 +08:00
|
|
|
}
|
2011-06-21 09:02:03 +08:00
|
|
|
|
|
|
|
SDValue ThreadPointer = DAG.getNode(MipsISD::ThreadPointer, dl, PtrVT);
|
|
|
|
return DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, Offset);
|
2008-07-30 03:29:50 +08:00
|
|
|
}
|
|
|
|
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue MipsTargetLowering::
|
2010-04-17 23:26:15 +08:00
|
|
|
LowerJumpTable(SDValue Op, SelectionDAG &DAG) const
|
2007-11-13 03:49:57 +08:00
|
|
|
{
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue ResNode;
|
2010-11-23 11:31:01 +08:00
|
|
|
SDValue HiPart;
|
2009-02-07 05:50:26 +08:00
|
|
|
// FIXME there isn't actually debug info here
|
2009-02-05 04:06:27 +08:00
|
|
|
DebugLoc dl = Op.getDebugLoc();
|
2009-09-02 01:27:58 +08:00
|
|
|
bool IsPIC = getTargetMachine().getRelocationModel() == Reloc::PIC_;
|
2011-04-02 05:41:06 +08:00
|
|
|
unsigned char OpFlag = IsPIC ? MipsII::MO_GOT : MipsII::MO_ABS_HI;
|
2007-11-13 03:49:57 +08:00
|
|
|
|
2009-08-11 06:56:29 +08:00
|
|
|
EVT PtrVT = Op.getValueType();
|
2007-11-13 03:49:57 +08:00
|
|
|
JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
|
|
|
|
|
2009-09-02 01:27:58 +08:00
|
|
|
SDValue JTI = DAG.getTargetJumpTable(JT->getIndex(), PtrVT, OpFlag);
|
|
|
|
|
2010-07-20 16:37:04 +08:00
|
|
|
if (!IsPIC) {
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue Ops[] = { JTI };
|
2009-09-02 01:27:58 +08:00
|
|
|
HiPart = DAG.getNode(MipsISD::Hi, dl, DAG.getVTList(MVT::i32), Ops, 1);
|
2011-05-28 09:07:07 +08:00
|
|
|
} else {// Emit Load from Global Pointer
|
|
|
|
JTI = DAG.getNode(MipsISD::WrapperPIC, dl, MVT::i32, JTI);
|
2010-09-21 14:44:06 +08:00
|
|
|
HiPart = DAG.getLoad(MVT::i32, dl, DAG.getEntryNode(), JTI,
|
|
|
|
MachinePointerInfo(),
|
2010-02-16 00:56:10 +08:00
|
|
|
false, false, 0);
|
2011-05-28 09:07:07 +08:00
|
|
|
}
|
2007-11-13 03:49:57 +08:00
|
|
|
|
2011-04-16 05:00:26 +08:00
|
|
|
SDValue JTILo = DAG.getTargetJumpTable(JT->getIndex(), PtrVT,
|
|
|
|
MipsII::MO_ABS_LO);
|
2011-04-02 05:41:06 +08:00
|
|
|
SDValue Lo = DAG.getNode(MipsISD::Lo, dl, MVT::i32, JTILo);
|
2009-08-12 04:47:22 +08:00
|
|
|
ResNode = DAG.getNode(ISD::ADD, dl, MVT::i32, HiPart, Lo);
|
2007-11-13 03:49:57 +08:00
|
|
|
|
|
|
|
return ResNode;
|
|
|
|
}
|
|
|
|
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue MipsTargetLowering::
|
2010-04-17 23:26:15 +08:00
|
|
|
LowerConstantPool(SDValue Op, SelectionDAG &DAG) const
|
2008-07-09 12:15:08 +08:00
|
|
|
{
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue ResNode;
|
2008-07-24 00:01:50 +08:00
|
|
|
ConstantPoolSDNode *N = cast<ConstantPoolSDNode>(Op);
|
2010-04-15 09:51:59 +08:00
|
|
|
const Constant *C = N->getConstVal();
|
2009-02-07 05:50:26 +08:00
|
|
|
// FIXME there isn't actually debug info here
|
|
|
|
DebugLoc dl = Op.getDebugLoc();
|
2008-07-24 00:01:50 +08:00
|
|
|
|
|
|
|
// gp_rel relocation
|
2010-11-23 11:31:01 +08:00
|
|
|
// FIXME: we should reference the constant pool using small data sections,
|
2011-04-15 13:18:47 +08:00
|
|
|
// but the asm printer currently doesn't support this feature without
|
2010-11-23 11:31:01 +08:00
|
|
|
// hacking it. This feature should come soon so we can uncomment the
|
2008-07-29 03:26:25 +08:00
|
|
|
// stuff below.
|
2009-08-03 10:22:28 +08:00
|
|
|
//if (IsInSmallSection(C->getType())) {
|
2009-08-12 04:47:22 +08:00
|
|
|
// SDValue GPRelNode = DAG.getNode(MipsISD::GPRel, MVT::i32, CP);
|
|
|
|
// SDValue GOT = DAG.getGLOBAL_OFFSET_TABLE(MVT::i32);
|
2010-11-23 11:31:01 +08:00
|
|
|
// ResNode = DAG.getNode(ISD::ADD, MVT::i32, GOT, GPRelNode);
|
2009-11-25 20:17:58 +08:00
|
|
|
|
|
|
|
if (getTargetMachine().getRelocationModel() != Reloc::PIC_) {
|
2011-04-02 05:41:06 +08:00
|
|
|
SDValue CPHi = DAG.getTargetConstantPool(C, MVT::i32, N->getAlignment(),
|
2011-04-16 05:51:11 +08:00
|
|
|
N->getOffset(), MipsII::MO_ABS_HI);
|
2011-04-02 05:41:06 +08:00
|
|
|
SDValue CPLo = DAG.getTargetConstantPool(C, MVT::i32, N->getAlignment(),
|
2011-04-16 05:51:11 +08:00
|
|
|
N->getOffset(), MipsII::MO_ABS_LO);
|
2011-04-02 05:41:06 +08:00
|
|
|
SDValue HiPart = DAG.getNode(MipsISD::Hi, dl, MVT::i32, CPHi);
|
|
|
|
SDValue Lo = DAG.getNode(MipsISD::Lo, dl, MVT::i32, CPLo);
|
2009-08-12 04:47:22 +08:00
|
|
|
ResNode = DAG.getNode(ISD::ADD, dl, MVT::i32, HiPart, Lo);
|
2009-11-25 20:17:58 +08:00
|
|
|
} else {
|
2010-11-23 11:31:01 +08:00
|
|
|
SDValue CP = DAG.getTargetConstantPool(C, MVT::i32, N->getAlignment(),
|
2011-04-02 05:41:06 +08:00
|
|
|
N->getOffset(), MipsII::MO_GOT);
|
2011-05-28 09:07:07 +08:00
|
|
|
CP = DAG.getNode(MipsISD::WrapperPIC, dl, MVT::i32, CP);
|
2010-11-23 11:31:01 +08:00
|
|
|
SDValue Load = DAG.getLoad(MVT::i32, dl, DAG.getEntryNode(),
|
2010-09-21 14:44:06 +08:00
|
|
|
CP, MachinePointerInfo::getConstantPool(),
|
|
|
|
false, false, 0);
|
2011-04-02 05:41:06 +08:00
|
|
|
SDValue CPLo = DAG.getTargetConstantPool(C, MVT::i32, N->getAlignment(),
|
2011-04-16 05:51:11 +08:00
|
|
|
N->getOffset(), MipsII::MO_ABS_LO);
|
2011-04-02 05:41:06 +08:00
|
|
|
SDValue Lo = DAG.getNode(MipsISD::Lo, dl, MVT::i32, CPLo);
|
2009-11-25 20:17:58 +08:00
|
|
|
ResNode = DAG.getNode(ISD::ADD, dl, MVT::i32, Load, Lo);
|
|
|
|
}
|
2008-07-24 00:01:50 +08:00
|
|
|
|
|
|
|
return ResNode;
|
2008-07-09 12:15:08 +08:00
|
|
|
}
|
|
|
|
|
2010-04-17 23:26:15 +08:00
|
|
|
SDValue MipsTargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG) const {
|
2010-04-17 22:41:14 +08:00
|
|
|
MachineFunction &MF = DAG.getMachineFunction();
|
|
|
|
MipsFunctionInfo *FuncInfo = MF.getInfo<MipsFunctionInfo>();
|
|
|
|
|
2010-02-07 05:00:02 +08:00
|
|
|
DebugLoc dl = Op.getDebugLoc();
|
2010-04-17 22:41:14 +08:00
|
|
|
SDValue FI = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
|
|
|
|
getPointerTy());
|
2010-02-07 05:00:02 +08:00
|
|
|
|
|
|
|
// vastart just stores the address of the VarArgsFrameIndex slot into the
|
|
|
|
// memory location argument.
|
|
|
|
const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
|
2010-09-22 01:50:43 +08:00
|
|
|
return DAG.getStore(Op.getOperand(0), dl, FI, Op.getOperand(1),
|
|
|
|
MachinePointerInfo(SV),
|
2010-02-16 00:56:10 +08:00
|
|
|
false, false, 0);
|
2010-02-07 05:00:02 +08:00
|
|
|
}
|
|
|
|
|
2011-05-26 03:32:07 +08:00
|
|
|
static SDValue LowerFCOPYSIGN32(SDValue Op, SelectionDAG &DAG) {
|
|
|
|
// FIXME: Use ext/ins instructions if target architecture is Mips32r2.
|
|
|
|
DebugLoc dl = Op.getDebugLoc();
|
|
|
|
SDValue Op0 = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Op.getOperand(0));
|
|
|
|
SDValue Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Op.getOperand(1));
|
|
|
|
SDValue And0 = DAG.getNode(ISD::AND, dl, MVT::i32, Op0,
|
|
|
|
DAG.getConstant(0x7fffffff, MVT::i32));
|
|
|
|
SDValue And1 = DAG.getNode(ISD::AND, dl, MVT::i32, Op1,
|
|
|
|
DAG.getConstant(0x80000000, MVT::i32));
|
|
|
|
SDValue Result = DAG.getNode(ISD::OR, dl, MVT::i32, And0, And1);
|
|
|
|
return DAG.getNode(ISD::BITCAST, dl, MVT::f32, Result);
|
|
|
|
}
|
|
|
|
|
|
|
|
static SDValue LowerFCOPYSIGN64(SDValue Op, SelectionDAG &DAG, bool isLittle) {
|
2011-06-09 07:55:35 +08:00
|
|
|
// FIXME:
|
2011-05-26 03:32:07 +08:00
|
|
|
// Use ext/ins instructions if target architecture is Mips32r2.
|
|
|
|
// Eliminate redundant mfc1 and mtc1 instructions.
|
|
|
|
unsigned LoIdx = 0, HiIdx = 1;
|
2011-06-09 07:55:35 +08:00
|
|
|
|
2011-05-26 03:32:07 +08:00
|
|
|
if (!isLittle)
|
|
|
|
std::swap(LoIdx, HiIdx);
|
|
|
|
|
|
|
|
DebugLoc dl = Op.getDebugLoc();
|
|
|
|
SDValue Word0 = DAG.getNode(MipsISD::ExtractElementF64, dl, MVT::i32,
|
|
|
|
Op.getOperand(0),
|
|
|
|
DAG.getConstant(LoIdx, MVT::i32));
|
|
|
|
SDValue Hi0 = DAG.getNode(MipsISD::ExtractElementF64, dl, MVT::i32,
|
|
|
|
Op.getOperand(0), DAG.getConstant(HiIdx, MVT::i32));
|
|
|
|
SDValue Hi1 = DAG.getNode(MipsISD::ExtractElementF64, dl, MVT::i32,
|
|
|
|
Op.getOperand(1), DAG.getConstant(HiIdx, MVT::i32));
|
|
|
|
SDValue And0 = DAG.getNode(ISD::AND, dl, MVT::i32, Hi0,
|
|
|
|
DAG.getConstant(0x7fffffff, MVT::i32));
|
|
|
|
SDValue And1 = DAG.getNode(ISD::AND, dl, MVT::i32, Hi1,
|
|
|
|
DAG.getConstant(0x80000000, MVT::i32));
|
|
|
|
SDValue Word1 = DAG.getNode(ISD::OR, dl, MVT::i32, And0, And1);
|
|
|
|
|
|
|
|
if (!isLittle)
|
|
|
|
std::swap(Word0, Word1);
|
|
|
|
|
|
|
|
return DAG.getNode(MipsISD::BuildPairF64, dl, MVT::f64, Word0, Word1);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDValue MipsTargetLowering::LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG)
|
|
|
|
const {
|
|
|
|
EVT Ty = Op.getValueType();
|
|
|
|
|
|
|
|
assert(Ty == MVT::f32 || Ty == MVT::f64);
|
|
|
|
|
|
|
|
if (Ty == MVT::f32)
|
|
|
|
return LowerFCOPYSIGN32(Op, DAG);
|
|
|
|
else
|
|
|
|
return LowerFCOPYSIGN64(Op, DAG, Subtarget->isLittle());
|
|
|
|
}
|
|
|
|
|
2011-06-02 08:24:44 +08:00
|
|
|
SDValue MipsTargetLowering::
|
|
|
|
LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const {
|
2011-06-16 08:40:02 +08:00
|
|
|
// check the depth
|
|
|
|
assert((cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue() == 0) &&
|
2011-06-08 02:58:42 +08:00
|
|
|
"Frame address can only be determined for current frame.");
|
2011-06-02 08:24:44 +08:00
|
|
|
|
|
|
|
MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
|
|
|
|
MFI->setFrameAddressIsTaken(true);
|
|
|
|
EVT VT = Op.getValueType();
|
|
|
|
DebugLoc dl = Op.getDebugLoc();
|
|
|
|
SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, Mips::FP, VT);
|
|
|
|
return FrameAddr;
|
|
|
|
}
|
|
|
|
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-06-06 15:42:06 +08:00
|
|
|
// Calling Convention Implementation
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-06-06 15:42:06 +08:00
|
|
|
|
|
|
|
#include "MipsGenCallingConv.inc"
|
|
|
|
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2010-11-23 11:31:01 +08:00
|
|
|
// TODO: Implement a generic logic using tblgen that can support this.
|
2009-03-19 10:12:28 +08:00
|
|
|
// Mips O32 ABI rules:
|
|
|
|
// ---
|
|
|
|
// i32 - Passed in A0, A1, A2, A3 and stack
|
2010-11-23 11:31:01 +08:00
|
|
|
// f32 - Only passed in f32 registers if no int reg has been used yet to hold
|
2009-03-19 10:12:28 +08:00
|
|
|
// an argument. Otherwise, passed in A1, A2, A3 and stack.
|
2010-11-23 11:31:01 +08:00
|
|
|
// f64 - Only passed in two aliased f32 registers if no int reg has been used
|
|
|
|
// yet to hold an argument. Otherwise, use A2, A3 and stack. If A1 is
|
2009-03-19 10:12:28 +08:00
|
|
|
// not used, it must be shadowed. If only A3 is avaiable, shadow it and
|
|
|
|
// go to stack.
|
2011-05-20 02:06:05 +08:00
|
|
|
//
|
|
|
|
// For vararg functions, all arguments are passed in A0, A1, A2, A3 and stack.
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2009-03-19 10:12:28 +08:00
|
|
|
|
2010-11-04 18:49:57 +08:00
|
|
|
static bool CC_MipsO32(unsigned ValNo, MVT ValVT,
|
2010-11-03 19:35:31 +08:00
|
|
|
MVT LocVT, CCValAssign::LocInfo LocInfo,
|
2009-03-19 10:12:28 +08:00
|
|
|
ISD::ArgFlagsTy ArgFlags, CCState &State) {
|
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
static const unsigned IntRegsSize=4, FloatRegsSize=2;
|
2009-03-19 10:12:28 +08:00
|
|
|
|
|
|
|
static const unsigned IntRegs[] = {
|
|
|
|
Mips::A0, Mips::A1, Mips::A2, Mips::A3
|
|
|
|
};
|
|
|
|
static const unsigned F32Regs[] = {
|
|
|
|
Mips::F12, Mips::F14
|
|
|
|
};
|
|
|
|
static const unsigned F64Regs[] = {
|
|
|
|
Mips::D6, Mips::D7
|
|
|
|
};
|
|
|
|
|
2011-05-25 03:18:33 +08:00
|
|
|
// ByVal Args
|
|
|
|
if (ArgFlags.isByVal()) {
|
|
|
|
State.HandleByVal(ValNo, ValVT, LocVT, LocInfo,
|
|
|
|
1 /*MinSize*/, 4 /*MinAlign*/, ArgFlags);
|
|
|
|
unsigned NextReg = (State.getNextStackOffset() + 3) / 4;
|
|
|
|
for (unsigned r = State.getFirstUnallocated(IntRegs, IntRegsSize);
|
|
|
|
r < std::min(IntRegsSize, NextReg); ++r)
|
|
|
|
State.AllocateReg(IntRegs[r]);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-02-07 03:20:49 +08:00
|
|
|
// Promote i8 and i16
|
|
|
|
if (LocVT == MVT::i8 || LocVT == MVT::i16) {
|
|
|
|
LocVT = MVT::i32;
|
|
|
|
if (ArgFlags.isSExt())
|
|
|
|
LocInfo = CCValAssign::SExt;
|
|
|
|
else if (ArgFlags.isZExt())
|
|
|
|
LocInfo = CCValAssign::ZExt;
|
|
|
|
else
|
|
|
|
LocInfo = CCValAssign::AExt;
|
|
|
|
}
|
|
|
|
|
2011-03-05 04:27:44 +08:00
|
|
|
unsigned Reg;
|
2010-02-07 03:20:49 +08:00
|
|
|
|
2011-05-20 02:06:05 +08:00
|
|
|
// f32 and f64 are allocated in A0, A1, A2, A3 when either of the following
|
|
|
|
// is true: function is vararg, argument is 3rd or higher, there is previous
|
|
|
|
// argument which is not f32 or f64.
|
|
|
|
bool AllocateFloatsInIntReg = State.isVarArg() || ValNo > 1
|
|
|
|
|| State.getFirstUnallocated(F32Regs, FloatRegsSize) != ValNo;
|
2011-05-20 04:29:48 +08:00
|
|
|
unsigned OrigAlign = ArgFlags.getOrigAlign();
|
|
|
|
bool isI64 = (ValVT == MVT::i32 && OrigAlign == 8);
|
2011-05-20 02:06:05 +08:00
|
|
|
|
|
|
|
if (ValVT == MVT::i32 || (ValVT == MVT::f32 && AllocateFloatsInIntReg)) {
|
2011-03-05 04:27:44 +08:00
|
|
|
Reg = State.AllocateReg(IntRegs, IntRegsSize);
|
2011-05-20 04:29:48 +08:00
|
|
|
// If this is the first part of an i64 arg,
|
|
|
|
// the allocated register must be either A0 or A2.
|
|
|
|
if (isI64 && (Reg == Mips::A1 || Reg == Mips::A3))
|
|
|
|
Reg = State.AllocateReg(IntRegs, IntRegsSize);
|
2011-03-05 04:27:44 +08:00
|
|
|
LocVT = MVT::i32;
|
2011-05-20 02:06:05 +08:00
|
|
|
} else if (ValVT == MVT::f64 && AllocateFloatsInIntReg) {
|
|
|
|
// Allocate int register and shadow next int register. If first
|
|
|
|
// available register is Mips::A1 or Mips::A3, shadow it too.
|
2011-03-05 04:27:44 +08:00
|
|
|
Reg = State.AllocateReg(IntRegs, IntRegsSize);
|
|
|
|
if (Reg == Mips::A1 || Reg == Mips::A3)
|
|
|
|
Reg = State.AllocateReg(IntRegs, IntRegsSize);
|
|
|
|
State.AllocateReg(IntRegs, IntRegsSize);
|
|
|
|
LocVT = MVT::i32;
|
2011-05-20 02:06:05 +08:00
|
|
|
} else if (ValVT.isFloatingPoint() && !AllocateFloatsInIntReg) {
|
|
|
|
// we are guaranteed to find an available float register
|
|
|
|
if (ValVT == MVT::f32) {
|
|
|
|
Reg = State.AllocateReg(F32Regs, FloatRegsSize);
|
|
|
|
// Shadow int register
|
|
|
|
State.AllocateReg(IntRegs, IntRegsSize);
|
|
|
|
} else {
|
|
|
|
Reg = State.AllocateReg(F64Regs, FloatRegsSize);
|
|
|
|
// Shadow int registers
|
|
|
|
unsigned Reg2 = State.AllocateReg(IntRegs, IntRegsSize);
|
|
|
|
if (Reg2 == Mips::A1 || Reg2 == Mips::A3)
|
|
|
|
State.AllocateReg(IntRegs, IntRegsSize);
|
|
|
|
State.AllocateReg(IntRegs, IntRegsSize);
|
|
|
|
}
|
2011-03-05 04:27:44 +08:00
|
|
|
} else
|
|
|
|
llvm_unreachable("Cannot handle this ValVT.");
|
2010-02-07 03:20:49 +08:00
|
|
|
|
2011-05-21 05:39:54 +08:00
|
|
|
unsigned SizeInBytes = ValVT.getSizeInBits() >> 3;
|
|
|
|
unsigned Offset = State.AllocateStack(SizeInBytes, OrigAlign);
|
|
|
|
|
|
|
|
if (!Reg)
|
2011-03-05 04:27:44 +08:00
|
|
|
State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo));
|
2011-05-21 05:39:54 +08:00
|
|
|
else
|
2011-03-05 04:27:44 +08:00
|
|
|
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
|
2010-02-07 03:20:49 +08:00
|
|
|
|
2011-03-05 04:27:44 +08:00
|
|
|
return false; // CC must always match
|
2010-02-07 03:20:49 +08:00
|
|
|
}
|
|
|
|
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
// Call Calling Convention Implementation
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-06-06 15:42:06 +08:00
|
|
|
|
2011-05-25 03:18:33 +08:00
|
|
|
static const unsigned O32IntRegsSize = 4;
|
|
|
|
|
|
|
|
static const unsigned O32IntRegs[] = {
|
|
|
|
Mips::A0, Mips::A1, Mips::A2, Mips::A3
|
|
|
|
};
|
|
|
|
|
|
|
|
// Write ByVal Arg to arg registers and stack.
|
|
|
|
static void
|
|
|
|
WriteByValArg(SDValue& Chain, DebugLoc dl,
|
|
|
|
SmallVector<std::pair<unsigned, SDValue>, 16>& RegsToPass,
|
|
|
|
SmallVector<SDValue, 8>& MemOpChains, int& LastFI,
|
|
|
|
MachineFrameInfo *MFI, SelectionDAG &DAG, SDValue Arg,
|
2011-05-26 01:32:06 +08:00
|
|
|
const CCValAssign &VA, const ISD::ArgFlagsTy& Flags,
|
|
|
|
MVT PtrType) {
|
2011-05-25 03:18:33 +08:00
|
|
|
unsigned FirstWord = VA.getLocMemOffset() / 4;
|
|
|
|
unsigned NumWords = (Flags.getByValSize() + 3) / 4;
|
|
|
|
unsigned LastWord = FirstWord + NumWords;
|
|
|
|
unsigned CurWord;
|
|
|
|
|
|
|
|
// copy the first 4 words of byval arg to registers A0 - A3
|
|
|
|
for (CurWord = FirstWord; CurWord < std::min(LastWord, O32IntRegsSize);
|
|
|
|
++CurWord) {
|
|
|
|
SDValue LoadPtr = DAG.getNode(ISD::ADD, dl, MVT::i32, Arg,
|
|
|
|
DAG.getConstant((CurWord - FirstWord) * 4,
|
|
|
|
MVT::i32));
|
|
|
|
SDValue LoadVal = DAG.getLoad(MVT::i32, dl, Chain, LoadPtr,
|
|
|
|
MachinePointerInfo(),
|
|
|
|
false, false, 0);
|
|
|
|
MemOpChains.push_back(LoadVal.getValue(1));
|
|
|
|
unsigned DstReg = O32IntRegs[CurWord];
|
|
|
|
RegsToPass.push_back(std::make_pair(DstReg, LoadVal));
|
|
|
|
}
|
|
|
|
|
|
|
|
// copy remaining part of byval arg to stack.
|
|
|
|
if (CurWord < LastWord) {
|
2011-06-09 07:55:35 +08:00
|
|
|
unsigned SizeInBytes = (LastWord - CurWord) * 4;
|
2011-05-25 03:18:33 +08:00
|
|
|
SDValue Src = DAG.getNode(ISD::ADD, dl, MVT::i32, Arg,
|
|
|
|
DAG.getConstant((CurWord - FirstWord) * 4,
|
|
|
|
MVT::i32));
|
|
|
|
LastFI = MFI->CreateFixedObject(SizeInBytes, CurWord * 4, true);
|
|
|
|
SDValue Dst = DAG.getFrameIndex(LastFI, PtrType);
|
|
|
|
Chain = DAG.getMemcpy(Chain, dl, Dst, Src,
|
|
|
|
DAG.getConstant(SizeInBytes, MVT::i32),
|
|
|
|
/*Align*/4,
|
|
|
|
/*isVolatile=*/false, /*AlwaysInline=*/false,
|
|
|
|
MachinePointerInfo(0), MachinePointerInfo(0));
|
|
|
|
MemOpChains.push_back(Chain);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
/// LowerCall - functions arguments are copied from virtual regs to
|
2009-01-26 11:15:54 +08:00
|
|
|
/// (physical regs)/(stack frame), CALLSEQ_START and CALLSEQ_END are emitted.
|
2010-02-07 03:20:49 +08:00
|
|
|
/// TODO: isTailCall.
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
SDValue
|
2010-02-03 07:55:14 +08:00
|
|
|
MipsTargetLowering::LowerCall(SDValue Chain, SDValue Callee,
|
2009-09-02 16:44:58 +08:00
|
|
|
CallingConv::ID CallConv, bool isVarArg,
|
2010-01-27 08:07:07 +08:00
|
|
|
bool &isTailCall,
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
const SmallVectorImpl<ISD::OutputArg> &Outs,
|
2010-07-07 23:54:55 +08:00
|
|
|
const SmallVectorImpl<SDValue> &OutVals,
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
const SmallVectorImpl<ISD::InputArg> &Ins,
|
|
|
|
DebugLoc dl, SelectionDAG &DAG,
|
2010-04-17 23:26:15 +08:00
|
|
|
SmallVectorImpl<SDValue> &InVals) const {
|
2010-01-27 08:07:07 +08:00
|
|
|
// MIPs target does not yet support tail call optimization.
|
|
|
|
isTailCall = false;
|
2007-07-12 07:16:16 +08:00
|
|
|
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
MachineFunction &MF = DAG.getMachineFunction();
|
2007-07-12 07:16:16 +08:00
|
|
|
MachineFrameInfo *MFI = MF.getFrameInfo();
|
2011-05-21 05:39:54 +08:00
|
|
|
const TargetFrameLowering *TFL = MF.getTarget().getFrameLowering();
|
2009-09-02 01:27:58 +08:00
|
|
|
bool IsPIC = getTargetMachine().getRelocationModel() == Reloc::PIC_;
|
2011-05-21 02:39:33 +08:00
|
|
|
MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
|
2007-06-06 15:42:06 +08:00
|
|
|
|
|
|
|
// Analyze operands of the call, assigning locations to each operand.
|
|
|
|
SmallVector<CCValAssign, 16> ArgLocs;
|
2011-06-09 07:55:35 +08:00
|
|
|
CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
|
|
|
|
getTargetMachine(), ArgLocs, *DAG.getContext());
|
2007-07-12 07:16:16 +08:00
|
|
|
|
2011-05-24 05:13:59 +08:00
|
|
|
if (Subtarget->isABI_O32())
|
2011-05-20 02:06:05 +08:00
|
|
|
CCInfo.AnalyzeCallOperands(Outs, CC_MipsO32);
|
2011-05-24 05:13:59 +08:00
|
|
|
else
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
CCInfo.AnalyzeCallOperands(Outs, CC_Mips);
|
2010-11-23 11:31:01 +08:00
|
|
|
|
2007-06-06 15:42:06 +08:00
|
|
|
// Get a count of how many bytes are to be pushed on the stack.
|
2011-06-09 01:39:33 +08:00
|
|
|
unsigned NextStackOffset = CCInfo.getNextStackOffset();
|
2007-06-06 15:42:06 +08:00
|
|
|
|
2011-06-09 01:39:33 +08:00
|
|
|
Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(NextStackOffset,
|
|
|
|
true));
|
2007-06-06 15:42:06 +08:00
|
|
|
|
2011-05-26 01:32:06 +08:00
|
|
|
// If this is the first call, create a stack frame object that points to
|
2011-06-09 01:39:33 +08:00
|
|
|
// a location to which .cprestore saves $gp.
|
2011-05-24 04:16:59 +08:00
|
|
|
if (IsPIC && !MipsFI->getGPFI())
|
2011-05-21 07:22:14 +08:00
|
|
|
MipsFI->setGPFI(MFI->CreateFixedObject(4, 0, true));
|
|
|
|
|
2011-06-21 08:40:49 +08:00
|
|
|
// Get the frame index of the stack frame object that points to the location
|
|
|
|
// of dynamically allocated area on the stack.
|
|
|
|
int DynAllocFI = MipsFI->getDynAllocFI();
|
|
|
|
|
2011-06-09 01:39:33 +08:00
|
|
|
// Update size of the maximum argument space.
|
|
|
|
// For O32, a minimum of four words (16 bytes) of argument space is
|
|
|
|
// allocated.
|
|
|
|
if (Subtarget->isABI_O32())
|
|
|
|
NextStackOffset = std::max(NextStackOffset, (unsigned)16);
|
|
|
|
|
|
|
|
unsigned MaxCallFrameSize = MipsFI->getMaxCallFrameSize();
|
|
|
|
|
|
|
|
if (MaxCallFrameSize < NextStackOffset) {
|
|
|
|
MipsFI->setMaxCallFrameSize(NextStackOffset);
|
|
|
|
|
2011-06-21 08:40:49 +08:00
|
|
|
// Set the offsets relative to $sp of the $gp restore slot and dynamically
|
|
|
|
// allocated stack space. These offsets must be aligned to a boundary
|
|
|
|
// determined by the stack alignment of the ABI.
|
|
|
|
unsigned StackAlignment = TFL->getStackAlignment();
|
|
|
|
NextStackOffset = (NextStackOffset + StackAlignment - 1) /
|
|
|
|
StackAlignment * StackAlignment;
|
|
|
|
|
|
|
|
if (IsPIC)
|
|
|
|
MFI->setObjectOffset(MipsFI->getGPFI(), NextStackOffset);
|
|
|
|
|
|
|
|
MFI->setObjectOffset(DynAllocFI, NextStackOffset);
|
2011-06-09 01:39:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// With EABI is it possible to have 16 args on registers.
|
|
|
|
SmallVector<std::pair<unsigned, SDValue>, 16> RegsToPass;
|
|
|
|
SmallVector<SDValue, 8> MemOpChains;
|
|
|
|
|
2011-06-09 07:55:35 +08:00
|
|
|
int FirstFI = -MFI->getNumFixedObjects() - 1, LastFI = 0;
|
2011-05-21 07:22:14 +08:00
|
|
|
|
2007-06-06 15:42:06 +08:00
|
|
|
// Walk the register/memloc assignments, inserting copies/loads.
|
|
|
|
for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
|
2010-07-07 23:54:55 +08:00
|
|
|
SDValue Arg = OutVals[i];
|
2007-06-06 15:42:06 +08:00
|
|
|
CCValAssign &VA = ArgLocs[i];
|
|
|
|
|
|
|
|
// Promote the value if needed.
|
|
|
|
switch (VA.getLocInfo()) {
|
2009-07-15 00:55:14 +08:00
|
|
|
default: llvm_unreachable("Unknown loc info!");
|
2010-11-23 11:31:01 +08:00
|
|
|
case CCValAssign::Full:
|
2009-03-19 10:12:28 +08:00
|
|
|
if (Subtarget->isABI_O32() && VA.isRegLoc()) {
|
2009-08-12 04:47:22 +08:00
|
|
|
if (VA.getValVT() == MVT::f32 && VA.getLocVT() == MVT::i32)
|
2010-11-23 11:31:01 +08:00
|
|
|
Arg = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Arg);
|
2009-08-12 04:47:22 +08:00
|
|
|
if (VA.getValVT() == MVT::f64 && VA.getLocVT() == MVT::i32) {
|
2011-04-16 05:51:11 +08:00
|
|
|
SDValue Lo = DAG.getNode(MipsISD::ExtractElementF64, dl, MVT::i32,
|
|
|
|
Arg, DAG.getConstant(0, MVT::i32));
|
2011-04-16 05:00:26 +08:00
|
|
|
SDValue Hi = DAG.getNode(MipsISD::ExtractElementF64, dl, MVT::i32,
|
|
|
|
Arg, DAG.getConstant(1, MVT::i32));
|
2011-04-16 03:52:08 +08:00
|
|
|
if (!Subtarget->isLittle())
|
|
|
|
std::swap(Lo, Hi);
|
2009-03-19 10:12:28 +08:00
|
|
|
RegsToPass.push_back(std::make_pair(VA.getLocReg(), Lo));
|
|
|
|
RegsToPass.push_back(std::make_pair(VA.getLocReg()+1, Hi));
|
|
|
|
continue;
|
2010-11-23 11:31:01 +08:00
|
|
|
}
|
2009-03-19 10:12:28 +08:00
|
|
|
}
|
|
|
|
break;
|
2008-03-17 14:57:02 +08:00
|
|
|
case CCValAssign::SExt:
|
2009-02-05 04:06:27 +08:00
|
|
|
Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
|
2008-03-17 14:57:02 +08:00
|
|
|
break;
|
|
|
|
case CCValAssign::ZExt:
|
2009-02-05 04:06:27 +08:00
|
|
|
Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
|
2008-03-17 14:57:02 +08:00
|
|
|
break;
|
|
|
|
case CCValAssign::AExt:
|
2009-02-05 04:06:27 +08:00
|
|
|
Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
|
2008-03-17 14:57:02 +08:00
|
|
|
break;
|
2007-06-06 15:42:06 +08:00
|
|
|
}
|
2010-11-23 11:31:01 +08:00
|
|
|
|
|
|
|
// Arguments that can be passed on register must be kept at
|
2007-11-05 11:02:32 +08:00
|
|
|
// RegsToPass vector
|
2007-06-06 15:42:06 +08:00
|
|
|
if (VA.isRegLoc()) {
|
|
|
|
RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
|
2008-03-17 14:57:02 +08:00
|
|
|
continue;
|
2007-06-06 15:42:06 +08:00
|
|
|
}
|
2010-11-23 11:31:01 +08:00
|
|
|
|
2009-03-19 10:12:28 +08:00
|
|
|
// Register can't get to this point...
|
2008-03-17 14:57:02 +08:00
|
|
|
assert(VA.isMemLoc());
|
2010-11-23 11:31:01 +08:00
|
|
|
|
2011-06-09 07:55:35 +08:00
|
|
|
// ByVal Arg.
|
2011-05-25 03:18:33 +08:00
|
|
|
ISD::ArgFlagsTy Flags = Outs[i].Flags;
|
|
|
|
if (Flags.isByVal()) {
|
|
|
|
assert(Subtarget->isABI_O32() &&
|
|
|
|
"No support for ByVal args by ABIs other than O32 yet.");
|
|
|
|
assert(Flags.getByValSize() &&
|
|
|
|
"ByVal args of size 0 should have been ignored by front-end.");
|
|
|
|
WriteByValArg(Chain, dl, RegsToPass, MemOpChains, LastFI, MFI, DAG, Arg,
|
|
|
|
VA, Flags, getPointerTy());
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2008-03-17 14:57:02 +08:00
|
|
|
// Create the frame index object for this incoming parameter
|
2011-06-09 07:55:35 +08:00
|
|
|
LastFI = MFI->CreateFixedObject(VA.getValVT().getSizeInBits()/8,
|
2011-05-24 08:23:52 +08:00
|
|
|
VA.getLocMemOffset(), true);
|
2011-05-21 07:22:14 +08:00
|
|
|
SDValue PtrOff = DAG.getFrameIndex(LastFI, getPointerTy());
|
2008-03-17 14:57:02 +08:00
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
// emit ISD::STORE whichs stores the
|
2008-03-17 14:57:02 +08:00
|
|
|
// parameter value to a stack Location
|
2010-09-22 01:50:43 +08:00
|
|
|
MemOpChains.push_back(DAG.getStore(Chain, dl, Arg, PtrOff,
|
|
|
|
MachinePointerInfo(),
|
2010-02-16 00:56:10 +08:00
|
|
|
false, false, 0));
|
2007-06-06 15:42:06 +08:00
|
|
|
}
|
|
|
|
|
2011-06-09 01:39:33 +08:00
|
|
|
// Extend range of indices of frame objects for outgoing arguments that were
|
|
|
|
// created during this function call. Skip this step if no such objects were
|
|
|
|
// created.
|
|
|
|
if (LastFI)
|
|
|
|
MipsFI->extendOutArgFIRange(FirstFI, LastFI);
|
|
|
|
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
// Transform all store nodes into one single node because all store
|
|
|
|
// nodes are independent of each other.
|
2010-11-23 11:31:01 +08:00
|
|
|
if (!MemOpChains.empty())
|
|
|
|
Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
|
2007-06-06 15:42:06 +08:00
|
|
|
&MemOpChains[0], MemOpChains.size());
|
|
|
|
|
2008-09-17 05:48:12 +08:00
|
|
|
// If the callee is a GlobalAddress/ExternalSymbol node (quite common, every
|
2010-11-23 11:31:01 +08:00
|
|
|
// direct call is) turn it into a TargetGlobalAddress/TargetExternalSymbol
|
|
|
|
// node so that legalize doesn't hack it.
|
2009-09-02 01:27:58 +08:00
|
|
|
unsigned char OpFlag = IsPIC ? MipsII::MO_GOT_CALL : MipsII::MO_NO_FLAG;
|
2011-04-05 01:11:07 +08:00
|
|
|
bool LoadSymAddr = false;
|
2011-04-08 03:51:44 +08:00
|
|
|
SDValue CalleeLo;
|
2011-04-05 01:11:07 +08:00
|
|
|
|
|
|
|
if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
|
2011-04-08 03:51:44 +08:00
|
|
|
if (IsPIC && G->getGlobal()->hasInternalLinkage()) {
|
|
|
|
Callee = DAG.getTargetGlobalAddress(G->getGlobal(), dl,
|
|
|
|
getPointerTy(), 0,MipsII:: MO_GOT);
|
|
|
|
CalleeLo = DAG.getTargetGlobalAddress(G->getGlobal(), dl, getPointerTy(),
|
|
|
|
0, MipsII::MO_ABS_LO);
|
|
|
|
} else {
|
|
|
|
Callee = DAG.getTargetGlobalAddress(G->getGlobal(), dl,
|
|
|
|
getPointerTy(), 0, OpFlag);
|
|
|
|
}
|
|
|
|
|
2011-04-05 01:11:07 +08:00
|
|
|
LoadSymAddr = true;
|
|
|
|
}
|
|
|
|
else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
|
2010-11-23 11:31:01 +08:00
|
|
|
Callee = DAG.getTargetExternalSymbol(S->getSymbol(),
|
2009-09-02 01:27:58 +08:00
|
|
|
getPointerTy(), OpFlag);
|
2011-04-05 01:11:07 +08:00
|
|
|
LoadSymAddr = true;
|
|
|
|
}
|
|
|
|
|
2011-05-20 10:30:51 +08:00
|
|
|
SDValue InFlag;
|
|
|
|
|
2011-04-05 01:11:07 +08:00
|
|
|
// Create nodes that load address of callee and copy it to T9
|
|
|
|
if (IsPIC) {
|
|
|
|
if (LoadSymAddr) {
|
2011-04-08 03:51:44 +08:00
|
|
|
// Load callee address
|
2011-05-28 09:07:07 +08:00
|
|
|
Callee = DAG.getNode(MipsISD::WrapperPIC, dl, MVT::i32, Callee);
|
2011-04-08 03:51:44 +08:00
|
|
|
SDValue LoadValue = DAG.getLoad(MVT::i32, dl, Chain, Callee,
|
|
|
|
MachinePointerInfo::getGOT(),
|
|
|
|
false, false, 0);
|
|
|
|
|
|
|
|
// Use GOT+LO if callee has internal linkage.
|
|
|
|
if (CalleeLo.getNode()) {
|
|
|
|
SDValue Lo = DAG.getNode(MipsISD::Lo, dl, MVT::i32, CalleeLo);
|
|
|
|
Callee = DAG.getNode(ISD::ADD, dl, MVT::i32, LoadValue, Lo);
|
|
|
|
} else
|
|
|
|
Callee = LoadValue;
|
|
|
|
|
2011-06-09 07:55:35 +08:00
|
|
|
// Use chain output from LoadValue
|
2011-04-08 03:51:44 +08:00
|
|
|
Chain = LoadValue.getValue(1);
|
2011-04-05 01:11:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// copy to T9
|
|
|
|
Chain = DAG.getCopyToReg(Chain, dl, Mips::T9, Callee, SDValue(0, 0));
|
|
|
|
InFlag = Chain.getValue(1);
|
|
|
|
Callee = DAG.getRegister(Mips::T9, MVT::i32);
|
|
|
|
}
|
2008-09-17 05:48:12 +08:00
|
|
|
|
2011-05-20 10:30:51 +08:00
|
|
|
// Build a sequence of copy-to-reg nodes chained together with token
|
|
|
|
// chain and flag operands which copy the outgoing args into registers.
|
|
|
|
// The InFlag in necessary since all emitted instructions must be
|
|
|
|
// stuck together.
|
|
|
|
for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
|
|
|
|
Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
|
|
|
|
RegsToPass[i].second, InFlag);
|
|
|
|
InFlag = Chain.getValue(1);
|
|
|
|
}
|
|
|
|
|
2007-06-06 15:42:06 +08:00
|
|
|
// MipsJmpLink = #chain, #target_address, #opt_in_flags...
|
2010-11-23 11:31:01 +08:00
|
|
|
// = Chain, Callee, Reg#1, Reg#2, ...
|
2007-06-06 15:42:06 +08:00
|
|
|
//
|
|
|
|
// Returns a chain & a flag for retval copy to use.
|
2010-12-21 10:38:05 +08:00
|
|
|
SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
|
2008-07-28 05:46:04 +08:00
|
|
|
SmallVector<SDValue, 8> Ops;
|
2007-06-06 15:42:06 +08:00
|
|
|
Ops.push_back(Chain);
|
|
|
|
Ops.push_back(Callee);
|
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
// Add argument registers to the end of the list so that they are
|
2007-06-06 15:42:06 +08:00
|
|
|
// known live into the call.
|
|
|
|
for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i)
|
|
|
|
Ops.push_back(DAG.getRegister(RegsToPass[i].first,
|
|
|
|
RegsToPass[i].second.getValueType()));
|
|
|
|
|
2008-08-29 05:40:38 +08:00
|
|
|
if (InFlag.getNode())
|
2007-06-06 15:42:06 +08:00
|
|
|
Ops.push_back(InFlag);
|
|
|
|
|
2009-02-05 04:06:27 +08:00
|
|
|
Chain = DAG.getNode(MipsISD::JmpLink, dl, NodeTys, &Ops[0], Ops.size());
|
2007-06-06 15:42:06 +08:00
|
|
|
InFlag = Chain.getValue(1);
|
|
|
|
|
2010-01-31 02:32:07 +08:00
|
|
|
// Create the CALLSEQ_END node.
|
2011-06-21 09:02:03 +08:00
|
|
|
Chain = DAG.getCALLSEQ_END(Chain,
|
|
|
|
DAG.getIntPtrConstant(NextStackOffset, true),
|
2010-01-31 02:32:07 +08:00
|
|
|
DAG.getIntPtrConstant(0, true), InFlag);
|
|
|
|
InFlag = Chain.getValue(1);
|
|
|
|
|
2007-06-06 15:42:06 +08:00
|
|
|
// Handle result values, copying them out of physregs into vregs that we
|
|
|
|
// return.
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
return LowerCallResult(Chain, InFlag, CallConv, isVarArg,
|
|
|
|
Ins, dl, DAG, InVals);
|
2007-06-06 15:42:06 +08:00
|
|
|
}
|
|
|
|
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
/// LowerCallResult - Lower the result values of a call into the
|
|
|
|
/// appropriate copies out of appropriate physical registers.
|
|
|
|
SDValue
|
|
|
|
MipsTargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag,
|
2009-09-02 16:44:58 +08: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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
const SmallVectorImpl<ISD::InputArg> &Ins,
|
|
|
|
DebugLoc dl, SelectionDAG &DAG,
|
2010-04-17 23:26:15 +08:00
|
|
|
SmallVectorImpl<SDValue> &InVals) const {
|
2007-06-06 15:42:06 +08:00
|
|
|
// Assign locations to each value returned by this call.
|
|
|
|
SmallVector<CCValAssign, 16> RVLocs;
|
2011-06-09 07:55:35 +08:00
|
|
|
CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
|
|
|
|
getTargetMachine(), RVLocs, *DAG.getContext());
|
2007-07-12 07:16:16 +08:00
|
|
|
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
CCInfo.AnalyzeCallResult(Ins, RetCC_Mips);
|
2007-06-06 15:42:06 +08:00
|
|
|
|
|
|
|
// Copy all of the result registers out of their specified physreg.
|
|
|
|
for (unsigned i = 0; i != RVLocs.size(); ++i) {
|
2009-02-05 04:06:27 +08:00
|
|
|
Chain = DAG.getCopyFromReg(Chain, dl, RVLocs[i].getLocReg(),
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
RVLocs[i].getValVT(), InFlag).getValue(1);
|
2007-06-06 15:42:06 +08:00
|
|
|
InFlag = Chain.getValue(2);
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
InVals.push_back(Chain.getValue(0));
|
2007-06-06 15:42:06 +08:00
|
|
|
}
|
2007-11-05 11:02:32 +08:00
|
|
|
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
return Chain;
|
2007-06-06 15:42:06 +08:00
|
|
|
}
|
|
|
|
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
// Formal Arguments Calling Convention Implementation
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2011-05-25 03:18:33 +08:00
|
|
|
static void ReadByValArg(MachineFunction &MF, SDValue Chain, DebugLoc dl,
|
|
|
|
std::vector<SDValue>& OutChains,
|
|
|
|
SelectionDAG &DAG, unsigned NumWords, SDValue FIN,
|
|
|
|
const CCValAssign &VA, const ISD::ArgFlagsTy& Flags) {
|
|
|
|
unsigned LocMem = VA.getLocMemOffset();
|
|
|
|
unsigned FirstWord = LocMem / 4;
|
|
|
|
|
|
|
|
// copy register A0 - A3 to frame object
|
|
|
|
for (unsigned i = 0; i < NumWords; ++i) {
|
|
|
|
unsigned CurWord = FirstWord + i;
|
|
|
|
if (CurWord >= O32IntRegsSize)
|
|
|
|
break;
|
|
|
|
|
|
|
|
unsigned SrcReg = O32IntRegs[CurWord];
|
|
|
|
unsigned Reg = AddLiveIn(MF, SrcReg, Mips::CPURegsRegisterClass);
|
|
|
|
SDValue StorePtr = DAG.getNode(ISD::ADD, dl, MVT::i32, FIN,
|
|
|
|
DAG.getConstant(i * 4, MVT::i32));
|
|
|
|
SDValue Store = DAG.getStore(Chain, dl, DAG.getRegister(Reg, MVT::i32),
|
|
|
|
StorePtr, MachinePointerInfo(), false,
|
|
|
|
false, 0);
|
|
|
|
OutChains.push_back(Store);
|
|
|
|
}
|
|
|
|
}
|
2007-06-06 15:42:06 +08:00
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
/// LowerFormalArguments - transform physical registers into virtual registers
|
2010-02-07 03:20:49 +08:00
|
|
|
/// and generate load operations for arguments places on the stack.
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
SDValue
|
|
|
|
MipsTargetLowering::LowerFormalArguments(SDValue Chain,
|
2011-04-16 05:00:26 +08:00
|
|
|
CallingConv::ID CallConv,
|
|
|
|
bool isVarArg,
|
|
|
|
const SmallVectorImpl<ISD::InputArg>
|
|
|
|
&Ins,
|
|
|
|
DebugLoc dl, SelectionDAG &DAG,
|
|
|
|
SmallVectorImpl<SDValue> &InVals)
|
2011-04-16 05:51:11 +08:00
|
|
|
const {
|
2008-08-04 15:12:52 +08:00
|
|
|
MachineFunction &MF = DAG.getMachineFunction();
|
2007-06-06 15:42:06 +08:00
|
|
|
MachineFrameInfo *MFI = MF.getFrameInfo();
|
2007-08-28 13:08:16 +08:00
|
|
|
MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
|
2007-07-12 07:16:16 +08:00
|
|
|
|
2010-04-17 22:41:14 +08:00
|
|
|
MipsFI->setVarArgsFrameIndex(0);
|
2007-06-06 15:42:06 +08:00
|
|
|
|
2010-02-07 03:20:49 +08:00
|
|
|
// Used with vargs to acumulate store chains.
|
|
|
|
std::vector<SDValue> OutChains;
|
|
|
|
|
2007-06-06 15:42:06 +08:00
|
|
|
// Assign locations to all of the incoming arguments.
|
|
|
|
SmallVector<CCValAssign, 16> ArgLocs;
|
2011-06-09 07:55:35 +08:00
|
|
|
CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
|
|
|
|
getTargetMachine(), ArgLocs, *DAG.getContext());
|
2007-07-12 07:16:16 +08:00
|
|
|
|
2009-03-19 10:12:28 +08:00
|
|
|
if (Subtarget->isABI_O32())
|
2011-05-20 02:06:05 +08:00
|
|
|
CCInfo.AnalyzeFormalArguments(Ins, CC_MipsO32);
|
2009-03-19 10:12:28 +08:00
|
|
|
else
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
CCInfo.AnalyzeFormalArguments(Ins, CC_Mips);
|
2009-03-19 10:12:28 +08:00
|
|
|
|
2011-05-21 07:22:14 +08:00
|
|
|
int LastFI = 0;// MipsFI->LastInArgFI is 0 at the entry of this function.
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
|
2007-06-06 15:42:06 +08:00
|
|
|
for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
|
|
|
|
CCValAssign &VA = ArgLocs[i];
|
|
|
|
|
|
|
|
// Arguments stored on registers
|
|
|
|
if (VA.isRegLoc()) {
|
2009-08-11 06:56:29 +08:00
|
|
|
EVT RegVT = VA.getLocVT();
|
2011-05-24 08:23:52 +08:00
|
|
|
unsigned ArgReg = VA.getLocReg();
|
2008-07-09 13:55:53 +08:00
|
|
|
TargetRegisterClass *RC = 0;
|
2009-03-19 10:12:28 +08:00
|
|
|
|
2009-08-12 04:47:22 +08:00
|
|
|
if (RegVT == MVT::i32)
|
2010-11-23 11:31:01 +08:00
|
|
|
RC = Mips::CPURegsRegisterClass;
|
|
|
|
else if (RegVT == MVT::f32)
|
2009-03-21 08:05:07 +08:00
|
|
|
RC = Mips::FGR32RegisterClass;
|
2009-08-12 04:47:22 +08:00
|
|
|
else if (RegVT == MVT::f64) {
|
2010-11-23 11:31:01 +08:00
|
|
|
if (!Subtarget->isSingleFloat())
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
RC = Mips::AFGR64RegisterClass;
|
2010-11-23 11:31:01 +08:00
|
|
|
} else
|
2010-02-07 03:20:49 +08:00
|
|
|
llvm_unreachable("RegVT not supported by FormalArguments Lowering");
|
2007-06-06 15:42:06 +08:00
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
// Transform the arguments stored on
|
2007-06-06 15:42:06 +08:00
|
|
|
// physical registers into virtual ones
|
2011-05-24 08:23:52 +08:00
|
|
|
unsigned Reg = AddLiveIn(DAG.getMachineFunction(), ArgReg, RC);
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
SDValue ArgValue = DAG.getCopyFromReg(Chain, dl, Reg, RegVT);
|
2010-11-23 11:31:01 +08:00
|
|
|
|
|
|
|
// If this is an 8 or 16-bit value, it has been passed promoted
|
|
|
|
// to 32 bits. Insert an assert[sz]ext to capture this, then
|
2007-06-06 15:42:06 +08:00
|
|
|
// truncate to the right size.
|
2009-03-19 10:12:28 +08:00
|
|
|
if (VA.getLocInfo() != CCValAssign::Full) {
|
2009-03-26 13:28:14 +08:00
|
|
|
unsigned Opcode = 0;
|
2009-03-19 10:12:28 +08:00
|
|
|
if (VA.getLocInfo() == CCValAssign::SExt)
|
|
|
|
Opcode = ISD::AssertSext;
|
|
|
|
else if (VA.getLocInfo() == CCValAssign::ZExt)
|
|
|
|
Opcode = ISD::AssertZext;
|
2009-03-26 13:28:14 +08:00
|
|
|
if (Opcode)
|
2010-11-23 11:31:01 +08:00
|
|
|
ArgValue = DAG.getNode(Opcode, dl, RegVT, ArgValue,
|
2009-03-26 13:28:14 +08:00
|
|
|
DAG.getValueType(VA.getValVT()));
|
2009-02-05 04:06:27 +08:00
|
|
|
ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
|
2009-03-19 10:12:28 +08:00
|
|
|
}
|
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
// Handle O32 ABI cases: i32->f32 and (i32,i32)->f64
|
2009-03-19 10:12:28 +08:00
|
|
|
if (Subtarget->isABI_O32()) {
|
2010-11-23 11:31:01 +08:00
|
|
|
if (RegVT == MVT::i32 && VA.getValVT() == MVT::f32)
|
|
|
|
ArgValue = DAG.getNode(ISD::BITCAST, dl, MVT::f32, ArgValue);
|
2009-08-12 04:47:22 +08:00
|
|
|
if (RegVT == MVT::i32 && VA.getValVT() == MVT::f64) {
|
2010-11-23 11:31:01 +08:00
|
|
|
unsigned Reg2 = AddLiveIn(DAG.getMachineFunction(),
|
2009-03-19 10:12:28 +08:00
|
|
|
VA.getLocReg()+1, RC);
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
SDValue ArgValue2 = DAG.getCopyFromReg(Chain, dl, Reg2, RegVT);
|
2011-04-16 03:52:08 +08:00
|
|
|
if (!Subtarget->isLittle())
|
|
|
|
std::swap(ArgValue, ArgValue2);
|
|
|
|
ArgValue = DAG.getNode(MipsISD::BuildPairF64, dl, MVT::f64,
|
|
|
|
ArgValue, ArgValue2);
|
2009-03-19 10:12:28 +08:00
|
|
|
}
|
|
|
|
}
|
2007-06-06 15:42:06 +08:00
|
|
|
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
InVals.push_back(ArgValue);
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
} else { // VA.isRegLoc()
|
|
|
|
|
2007-06-06 15:42:06 +08:00
|
|
|
// sanity check
|
|
|
|
assert(VA.isMemLoc());
|
2010-02-07 03:20:49 +08:00
|
|
|
|
2011-05-25 03:18:33 +08:00
|
|
|
ISD::ArgFlagsTy Flags = Ins[i].Flags;
|
|
|
|
|
|
|
|
if (Flags.isByVal()) {
|
|
|
|
assert(Subtarget->isABI_O32() &&
|
|
|
|
"No support for ByVal args by ABIs other than O32 yet.");
|
|
|
|
assert(Flags.getByValSize() &&
|
|
|
|
"ByVal args of size 0 should have been ignored by front-end.");
|
|
|
|
unsigned NumWords = (Flags.getByValSize() + 3) / 4;
|
|
|
|
LastFI = MFI->CreateFixedObject(NumWords * 4, VA.getLocMemOffset(),
|
|
|
|
true);
|
|
|
|
SDValue FIN = DAG.getFrameIndex(LastFI, getPointerTy());
|
|
|
|
InVals.push_back(FIN);
|
|
|
|
ReadByValArg(MF, Chain, dl, OutChains, DAG, NumWords, FIN, VA, Flags);
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
// The stack pointer offset is relative to the caller stack frame.
|
2011-05-24 08:23:52 +08:00
|
|
|
LastFI = MFI->CreateFixedObject(VA.getValVT().getSizeInBits()/8,
|
|
|
|
VA.getLocMemOffset(), true);
|
2007-06-06 15:42:06 +08:00
|
|
|
|
|
|
|
// Create load nodes to retrieve arguments from the stack
|
2011-05-21 07:22:14 +08:00
|
|
|
SDValue FIN = DAG.getFrameIndex(LastFI, getPointerTy());
|
2010-09-21 14:44:06 +08:00
|
|
|
InVals.push_back(DAG.getLoad(VA.getValVT(), dl, Chain, FIN,
|
2011-05-21 07:22:14 +08:00
|
|
|
MachinePointerInfo::getFixedStack(LastFI),
|
2010-02-16 00:56:10 +08:00
|
|
|
false, false, 0));
|
2007-06-06 15:42:06 +08:00
|
|
|
}
|
|
|
|
}
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
|
|
|
|
// The mips ABIs for returning structs by value requires that we copy
|
|
|
|
// the sret argument into $v0 for the return. Save the argument into
|
|
|
|
// a virtual register so that we can access it from the return points.
|
|
|
|
if (DAG.getMachineFunction().getFunction()->hasStructRetAttr()) {
|
|
|
|
unsigned Reg = MipsFI->getSRetReturnReg();
|
|
|
|
if (!Reg) {
|
2009-08-12 04:47:22 +08:00
|
|
|
Reg = MF.getRegInfo().createVirtualRegister(getRegClassFor(MVT::i32));
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
MipsFI->setSRetReturnReg(Reg);
|
|
|
|
}
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
SDValue Copy = DAG.getCopyToReg(DAG.getEntryNode(), dl, Reg, InVals[0]);
|
2009-08-12 04:47:22 +08:00
|
|
|
Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
}
|
|
|
|
|
2011-03-10 03:22:22 +08:00
|
|
|
if (isVarArg && Subtarget->isABI_O32()) {
|
2011-05-24 08:23:52 +08:00
|
|
|
// Record the frame index of the first variable argument
|
2011-06-09 07:55:35 +08:00
|
|
|
// which is a value necessary to VASTART.
|
2011-05-24 08:23:52 +08:00
|
|
|
unsigned NextStackOffset = CCInfo.getNextStackOffset();
|
2011-05-25 03:18:33 +08:00
|
|
|
assert(NextStackOffset % 4 == 0 &&
|
|
|
|
"NextStackOffset must be aligned to 4-byte boundaries.");
|
2011-05-24 08:23:52 +08:00
|
|
|
LastFI = MFI->CreateFixedObject(4, NextStackOffset, true);
|
|
|
|
MipsFI->setVarArgsFrameIndex(LastFI);
|
2011-05-26 01:32:06 +08:00
|
|
|
|
|
|
|
// If NextStackOffset is smaller than o32's 16-byte reserved argument area,
|
|
|
|
// copy the integer registers that have not been used for argument passing
|
|
|
|
// to the caller's stack frame.
|
2011-05-24 08:23:52 +08:00
|
|
|
for (; NextStackOffset < 16; NextStackOffset += 4) {
|
2011-03-10 03:22:22 +08:00
|
|
|
TargetRegisterClass *RC = Mips::CPURegsRegisterClass;
|
2011-05-24 08:23:52 +08:00
|
|
|
unsigned Idx = NextStackOffset / 4;
|
|
|
|
unsigned Reg = AddLiveIn(DAG.getMachineFunction(), O32IntRegs[Idx], RC);
|
|
|
|
SDValue ArgValue = DAG.getCopyFromReg(Chain, dl, Reg, MVT::i32);
|
2011-05-24 04:16:59 +08:00
|
|
|
LastFI = MFI->CreateFixedObject(4, NextStackOffset, true);
|
2011-05-24 08:23:52 +08:00
|
|
|
SDValue PtrOff = DAG.getFrameIndex(LastFI, getPointerTy());
|
|
|
|
OutChains.push_back(DAG.getStore(Chain, dl, ArgValue, PtrOff,
|
|
|
|
MachinePointerInfo(),
|
|
|
|
false, false, 0));
|
2010-02-07 03:20:49 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-21 07:22:14 +08:00
|
|
|
MipsFI->setLastInArgFI(LastFI);
|
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
// All stores are grouped in one node to allow the matching between
|
2010-02-07 03:20:49 +08:00
|
|
|
// the size of Ins and InVals. This only happens when on varg functions
|
|
|
|
if (!OutChains.empty()) {
|
|
|
|
OutChains.push_back(Chain);
|
|
|
|
Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
|
|
|
|
&OutChains[0], OutChains.size());
|
|
|
|
}
|
|
|
|
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
return Chain;
|
2007-06-06 15:42:06 +08:00
|
|
|
}
|
|
|
|
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-06-06 15:42:06 +08:00
|
|
|
// Return Value Calling Convention Implementation
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-06-06 15:42:06 +08:00
|
|
|
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
SDValue
|
|
|
|
MipsTargetLowering::LowerReturn(SDValue Chain,
|
2009-09-02 16:44:58 +08: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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
const SmallVectorImpl<ISD::OutputArg> &Outs,
|
2010-07-07 23:54:55 +08:00
|
|
|
const SmallVectorImpl<SDValue> &OutVals,
|
2010-04-17 23:26:15 +08:00
|
|
|
DebugLoc dl, SelectionDAG &DAG) 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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
|
2007-06-06 15:42:06 +08:00
|
|
|
// CCValAssign - represent the assignment of
|
|
|
|
// the return value to a location
|
|
|
|
SmallVector<CCValAssign, 16> RVLocs;
|
|
|
|
|
|
|
|
// CCState - Info about the registers and stack slot.
|
2011-06-09 07:55:35 +08:00
|
|
|
CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
|
|
|
|
getTargetMachine(), RVLocs, *DAG.getContext());
|
2007-06-06 15:42:06 +08:00
|
|
|
|
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.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
// Analize return values.
|
|
|
|
CCInfo.AnalyzeReturn(Outs, RetCC_Mips);
|
2007-06-06 15:42:06 +08:00
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
// If this is the first return lowered for this function, add
|
2007-06-06 15:42:06 +08:00
|
|
|
// the regs to the liveout set for the function.
|
2007-12-31 12:13:23 +08:00
|
|
|
if (DAG.getMachineFunction().getRegInfo().liveout_empty()) {
|
2007-06-06 15:42:06 +08:00
|
|
|
for (unsigned i = 0; i != RVLocs.size(); ++i)
|
2007-07-12 07:16:16 +08:00
|
|
|
if (RVLocs[i].isRegLoc())
|
2011-04-16 05:51:11 +08:00
|
|
|
DAG.getMachineFunction().getRegInfo().addLiveOut(RVLocs[i].getLocReg());
|
2007-06-06 15:42:06 +08:00
|
|
|
}
|
|
|
|
|
2008-07-28 05:46:04 +08:00
|
|
|
SDValue Flag;
|
2007-06-06 15:42:06 +08:00
|
|
|
|
|
|
|
// Copy the result values into the output registers.
|
|
|
|
for (unsigned i = 0; i != RVLocs.size(); ++i) {
|
|
|
|
CCValAssign &VA = RVLocs[i];
|
|
|
|
assert(VA.isRegLoc() && "Can only return in registers!");
|
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(),
|
2010-07-07 23:54:55 +08:00
|
|
|
OutVals[i], Flag);
|
2007-06-06 15:42:06 +08:00
|
|
|
|
|
|
|
// guarantee that all emitted copies are
|
|
|
|
// stuck together, avoiding something bad
|
|
|
|
Flag = Chain.getValue(1);
|
|
|
|
}
|
|
|
|
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
// The mips ABIs for returning structs by value requires that we copy
|
|
|
|
// the sret argument into $v0 for the return. We saved the argument into
|
|
|
|
// a virtual register in the entry block, so now we copy the value out
|
|
|
|
// and into $v0.
|
|
|
|
if (DAG.getMachineFunction().getFunction()->hasStructRetAttr()) {
|
|
|
|
MachineFunction &MF = DAG.getMachineFunction();
|
|
|
|
MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
|
|
|
|
unsigned Reg = MipsFI->getSRetReturnReg();
|
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
if (!Reg)
|
2009-07-15 00:55:14 +08:00
|
|
|
llvm_unreachable("sret virtual register not created in the entry block");
|
2009-02-05 07:02:30 +08:00
|
|
|
SDValue Val = DAG.getCopyFromReg(Chain, dl, Reg, getPointerTy());
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
|
2009-02-05 07:02:30 +08:00
|
|
|
Chain = DAG.getCopyToReg(Chain, dl, Mips::V0, Val, Flag);
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
Flag = Chain.getValue(1);
|
|
|
|
}
|
|
|
|
|
2007-06-06 15:42:06 +08:00
|
|
|
// Return on Mips is always a "jr $ra"
|
2008-08-29 05:40:38 +08:00
|
|
|
if (Flag.getNode())
|
2010-11-23 11:31:01 +08:00
|
|
|
return DAG.getNode(MipsISD::Ret, dl, MVT::Other,
|
2009-08-12 04:47:22 +08:00
|
|
|
Chain, DAG.getRegister(Mips::RA, MVT::i32), Flag);
|
2007-06-06 15:42:06 +08:00
|
|
|
else // Return Void
|
2010-11-23 11:31:01 +08:00
|
|
|
return DAG.getNode(MipsISD::Ret, dl, MVT::Other,
|
2009-08-12 04:47:22 +08:00
|
|
|
Chain, DAG.getRegister(Mips::RA, MVT::i32));
|
2007-06-06 15:42:06 +08:00
|
|
|
}
|
2007-08-22 00:09:25 +08:00
|
|
|
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-08-22 00:09:25 +08:00
|
|
|
// Mips Inline Assembly Support
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-08-22 00:09:25 +08:00
|
|
|
|
|
|
|
/// getConstraintType - Given a constraint letter, return the type of
|
|
|
|
/// constraint it is for this target.
|
|
|
|
MipsTargetLowering::ConstraintType MipsTargetLowering::
|
2010-11-23 11:31:01 +08:00
|
|
|
getConstraintType(const std::string &Constraint) const
|
2007-08-22 00:09:25 +08:00
|
|
|
{
|
2010-11-23 11:31:01 +08:00
|
|
|
// Mips specific constrainy
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
// GCC config/mips/constraints.md
|
|
|
|
//
|
2010-11-23 11:31:01 +08:00
|
|
|
// 'd' : An address register. Equivalent to r
|
|
|
|
// unless generating MIPS16 code.
|
|
|
|
// 'y' : Equivalent to r; retained for
|
|
|
|
// backwards compatibility.
|
|
|
|
// 'f' : Floating Point registers.
|
2007-08-22 00:09:25 +08:00
|
|
|
if (Constraint.size() == 1) {
|
|
|
|
switch (Constraint[0]) {
|
|
|
|
default : break;
|
2010-11-23 11:31:01 +08:00
|
|
|
case 'd':
|
|
|
|
case 'y':
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
case 'f':
|
2007-08-22 00:09:25 +08:00
|
|
|
return C_RegisterClass;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return TargetLowering::getConstraintType(Constraint);
|
|
|
|
}
|
|
|
|
|
2010-10-30 01:29:13 +08:00
|
|
|
/// Examine constraint type and operand type and determine a weight value.
|
|
|
|
/// This object must already have been set up with the operand type
|
|
|
|
/// and the current alternative constraint selected.
|
|
|
|
TargetLowering::ConstraintWeight
|
|
|
|
MipsTargetLowering::getSingleConstraintMatchWeight(
|
|
|
|
AsmOperandInfo &info, const char *constraint) const {
|
|
|
|
ConstraintWeight weight = CW_Invalid;
|
|
|
|
Value *CallOperandVal = info.CallOperandVal;
|
|
|
|
// If we don't have a value, we can't do a match,
|
|
|
|
// but allow it at the lowest weight.
|
|
|
|
if (CallOperandVal == NULL)
|
|
|
|
return CW_Default;
|
|
|
|
const Type *type = CallOperandVal->getType();
|
|
|
|
// Look at the constraint type.
|
|
|
|
switch (*constraint) {
|
|
|
|
default:
|
|
|
|
weight = TargetLowering::getSingleConstraintMatchWeight(info, constraint);
|
|
|
|
break;
|
2010-11-23 11:31:01 +08:00
|
|
|
case 'd':
|
|
|
|
case 'y':
|
2010-10-30 01:29:13 +08:00
|
|
|
if (type->isIntegerTy())
|
|
|
|
weight = CW_Register;
|
|
|
|
break;
|
|
|
|
case 'f':
|
|
|
|
if (type->isFloatTy())
|
|
|
|
weight = CW_Register;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return weight;
|
|
|
|
}
|
|
|
|
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
/// getRegClassForInlineAsmConstraint - Given a constraint letter (e.g. "r"),
|
|
|
|
/// return a list of registers that can be used to satisfy the constraint.
|
|
|
|
/// This should only be used for C_RegisterClass constraints.
|
2007-08-22 00:09:25 +08:00
|
|
|
std::pair<unsigned, const TargetRegisterClass*> MipsTargetLowering::
|
2009-08-11 06:56:29 +08:00
|
|
|
getRegForInlineAsmConstraint(const std::string &Constraint, EVT VT) const
|
2007-08-22 00:09:25 +08:00
|
|
|
{
|
|
|
|
if (Constraint.size() == 1) {
|
|
|
|
switch (Constraint[0]) {
|
|
|
|
case 'r':
|
|
|
|
return std::make_pair(0U, Mips::CPURegsRegisterClass);
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
case 'f':
|
2009-08-12 04:47:22 +08:00
|
|
|
if (VT == MVT::f32)
|
2009-03-21 08:05:07 +08:00
|
|
|
return std::make_pair(0U, Mips::FGR32RegisterClass);
|
2010-11-23 11:31:01 +08:00
|
|
|
if (VT == MVT::f64)
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
if ((!Subtarget->isSingleFloat()) && (!Subtarget->isFP64bit()))
|
|
|
|
return std::make_pair(0U, Mips::AFGR64RegisterClass);
|
2007-08-22 00:09:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return TargetLowering::getRegForInlineAsmConstraint(Constraint, VT);
|
|
|
|
}
|
|
|
|
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
/// Given a register class constraint, like 'r', if this corresponds directly
|
|
|
|
/// to an LLVM register class, return a register of 0 and the register class
|
|
|
|
/// pointer.
|
2007-08-22 00:09:25 +08:00
|
|
|
std::vector<unsigned> MipsTargetLowering::
|
|
|
|
getRegClassForInlineAsmConstraint(const std::string &Constraint,
|
2009-08-11 06:56:29 +08:00
|
|
|
EVT VT) const
|
2007-08-22 00:09:25 +08:00
|
|
|
{
|
|
|
|
if (Constraint.size() != 1)
|
|
|
|
return std::vector<unsigned>();
|
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
switch (Constraint[0]) {
|
2007-08-22 00:09:25 +08:00
|
|
|
default : break;
|
|
|
|
case 'r':
|
|
|
|
// GCC Mips Constraint Letters
|
2010-11-23 11:31:01 +08:00
|
|
|
case 'd':
|
|
|
|
case 'y':
|
|
|
|
return make_vector<unsigned>(Mips::T0, Mips::T1, Mips::T2, Mips::T3,
|
|
|
|
Mips::T4, Mips::T5, Mips::T6, Mips::T7, Mips::S0, Mips::S1,
|
|
|
|
Mips::S2, Mips::S3, Mips::S4, Mips::S5, Mips::S6, Mips::S7,
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
Mips::T8, 0);
|
|
|
|
|
|
|
|
case 'f':
|
2009-08-12 04:47:22 +08:00
|
|
|
if (VT == MVT::f32) {
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
if (Subtarget->isSingleFloat())
|
|
|
|
return make_vector<unsigned>(Mips::F2, Mips::F3, Mips::F4, Mips::F5,
|
|
|
|
Mips::F6, Mips::F7, Mips::F8, Mips::F9, Mips::F10, Mips::F11,
|
|
|
|
Mips::F20, Mips::F21, Mips::F22, Mips::F23, Mips::F24,
|
|
|
|
Mips::F25, Mips::F26, Mips::F27, Mips::F28, Mips::F29,
|
|
|
|
Mips::F30, Mips::F31, 0);
|
|
|
|
else
|
2010-11-23 11:31:01 +08:00
|
|
|
return make_vector<unsigned>(Mips::F2, Mips::F4, Mips::F6, Mips::F8,
|
|
|
|
Mips::F10, Mips::F20, Mips::F22, Mips::F24, Mips::F26,
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
Mips::F28, Mips::F30, 0);
|
2008-07-08 17:33:14 +08:00
|
|
|
}
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
|
2010-11-23 11:31:01 +08:00
|
|
|
if (VT == MVT::f64)
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
if ((!Subtarget->isSingleFloat()) && (!Subtarget->isFP64bit()))
|
2010-11-23 11:31:01 +08:00
|
|
|
return make_vector<unsigned>(Mips::D1, Mips::D2, Mips::D3, Mips::D4,
|
|
|
|
Mips::D5, Mips::D10, Mips::D11, Mips::D12, Mips::D13,
|
Several changes to Mips backend, experimental fp support being the most
important.
- Cleanup in the Subtarget info with addition of new features, not all support
yet, but they allow the future inclusion of features easier. Among new features,
we have : Arch family info (mips1, mips2, ...), ABI info (o32, eabi), 64-bit
integer
and float registers, allegrex vector FPU (VFPU), single float only support.
- TargetMachine now detects allegrex core.
- Added allegrex (Mips32r2) sext_inreg instructions.
- *Added Float Point Instructions*, handling single float only, and
aliased accesses for 32-bit FPUs.
- Some cleanup in FP instruction formats and FP register classes.
- Calling conventions improved to support mips 32-bit EABI.
- Added Asm Printer support for fp cond codes.
- Added support for sret copy to a return register.
- EABI support added into LowerCALL and FORMAL_ARGS.
- MipsFunctionInfo now keeps a virtual register per function to track the
sret on function entry until function ret.
- MipsInstrInfo FP support into methods (isMoveInstr, isLoadFromStackSlot, ...),
FP cond codes mapping and initial FP Branch Analysis.
- Two new Mips SDNode to handle fp branch and compare instructions : FPBrcond,
FPCmp
- MipsTargetLowering : handling different FP classes, Allegrex support, sret
return copy, no homing location within EABI, non 32-bit stack objects
arguments, and asm constraint for float.
llvm-svn: 53146
2008-07-06 03:05:21 +08:00
|
|
|
Mips::D14, Mips::D15, 0);
|
2007-08-22 00:09:25 +08:00
|
|
|
}
|
|
|
|
return std::vector<unsigned>();
|
|
|
|
}
|
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
|
|
|
|
MipsTargetLowering::isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const {
|
|
|
|
// The Mips target isn't yet aware of offsets.
|
|
|
|
return false;
|
|
|
|
}
|
2009-10-28 03:56:55 +08:00
|
|
|
|
2009-10-28 09:43:28 +08:00
|
|
|
bool MipsTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const {
|
|
|
|
if (VT != MVT::f32 && VT != MVT::f64)
|
|
|
|
return false;
|
2011-01-19 03:41:41 +08:00
|
|
|
if (Imm.isNegZero())
|
|
|
|
return false;
|
2009-10-28 03:56:55 +08:00
|
|
|
return Imm.isZero();
|
|
|
|
}
|