setOperationAction(ISD::GlobalTLSAddress, MVT::i32, Custom);
setOperationAction(ISD::RET, MVT::Other, Custom);
setOperationAction(ISD::JumpTable, MVT::i32, Custom);
- setOperationAction(ISD::ConstantPool, MVT::f32, Custom);
+ setOperationAction(ISD::ConstantPool, MVT::i32, Custom);
setOperationAction(ISD::SELECT_CC, MVT::i32, Custom);
setOperationAction(ISD::SELECT_CC, MVT::f32, Custom);
return VReg;
}
+// A address must be loaded from a small section if its size is less than the
+// small section size threshold. Data in this section must be addressed using
+// gp_rel operator.
+bool MipsTargetLowering::IsInSmallSection(unsigned Size) {
+ return (Size > 0 && (Size <= Subtarget->getSSectionThreshold()));
+}
+
// Discover if this global address can be placed into small data/bss section.
-// This should happen for globals with size less than small section size
-// threshold in no abicall environments. Data in this section must be addressed
-// using gp_rel operator.
bool MipsTargetLowering::IsGlobalInSmallSection(GlobalValue *GV)
{
const TargetData *TD = getTargetData();
return false;
}
- if (Size > 0 && (Size <= Subtarget->getSSectionThreshold()))
- return true;
-
- return false;
+ return IsInSmallSection(Size);
}
//===----------------------------------------------------------------------===//
SDOperand MipsTargetLowering::
LowerConstantPool(SDOperand Op, SelectionDAG &DAG)
{
- assert(0 && "ConstantPool not implemented for MIPS.");
- return SDOperand(); // Not reached
+ SDOperand ResNode;
+ ConstantPoolSDNode *N = cast<ConstantPoolSDNode>(Op);
+ Constant *C = N->getConstVal();
+ SDOperand CP = DAG.getTargetConstantPool(C, MVT::i32, N->getAlignment());
+
+ // gp_rel relocation
+ if (!Subtarget->hasABICall() &&
+ IsInSmallSection(getTargetData()->getABITypeSize(C->getType()))) {
+ SDOperand GPRelNode = DAG.getNode(MipsISD::GPRel, MVT::i32, CP);
+ SDOperand GOT = DAG.getNode(ISD::GLOBAL_OFFSET_TABLE, MVT::i32);
+ ResNode = DAG.getNode(ISD::ADD, MVT::i32, GOT, GPRelNode);
+ } else { // %hi/%lo relocation
+ SDOperand HiPart = DAG.getNode(MipsISD::Hi, MVT::i32, CP);
+ SDOperand Lo = DAG.getNode(MipsISD::Lo, MVT::i32, CP);
+ ResNode = DAG.getNode(ISD::ADD, MVT::i32, HiPart, Lo);
+ }
+
+ return ResNode;
}
//===----------------------------------------------------------------------===//
{
// FrameIndex for return slot.
int ReturnAddrIndex;
-
- // const MipsSubtarget &MipsSubTarget;
public:
explicit MipsTargetLowering(MipsTargetMachine &TM);
SDNode *LowerCallResult(SDOperand Chain, SDOperand InFlag, SDNode*TheCall,
unsigned CallingConv, SelectionDAG &DAG);
bool IsGlobalInSmallSection(GlobalValue *GV);
+ bool IsInSmallSection(unsigned Size);
// Lower Operand specifics
SDOperand LowerRET(SDOperand Op, SelectionDAG &DAG);
def : Pat<(MipsJmpLink CPURegs:$dst),
(JALR CPURegs:$dst)>;
-// GlobalAddress, Constant Pool, ExternalSymbol, and JumpTable
+// hi/lo relocs
def : Pat<(MipsHi tglobaladdr:$in), (LUi tglobaladdr:$in)>;
-//def : Pat<(MipsLo tglobaladdr:$in), (ADDiu ZERO, tglobaladdr:$in)>;
def : Pat<(add CPURegs:$hi, (MipsLo tglobaladdr:$lo)),
(ADDiu CPURegs:$hi, tglobaladdr:$lo)>;
+
def : Pat<(MipsHi tjumptable:$in), (LUi tjumptable:$in)>;
-//def : Pat<(MipsLo tjumptable:$in), (ADDiu ZERO, tjumptable:$in)>;
def : Pat<(add CPURegs:$hi, (MipsLo tjumptable:$lo)),
(ADDiu CPURegs:$hi, tjumptable:$lo)>;
+
+def : Pat<(MipsHi tconstpool:$in), (LUi tconstpool:$in)>;
+def : Pat<(add CPURegs:$hi, (MipsLo tconstpool:$lo)),
+ (ADDiu CPURegs:$hi, tconstpool:$lo)>;
+
+// gp_rel relocs
def : Pat<(add CPURegs:$gp, (MipsGPRel tglobaladdr:$in)),
(ADDiu CPURegs:$gp, tglobaladdr:$in)>;
+def : Pat<(add CPURegs:$gp, (MipsGPRel tconstpool:$in)),
+ (ADDiu CPURegs:$gp, tconstpool:$in)>;
// Mips does not have "not", so we expand our way
def : Pat<(not CPURegs:$in),
MipsTargetAsmInfo::MipsTargetAsmInfo(const MipsTargetMachine &TM):
ELFTargetAsmInfo(TM) {
- MipsTM = &TM;
+ Subtarget = &TM.getSubtarget<MipsSubtarget>();
AlignmentIsInBytes = false;
COMMDirectiveTakesAlignment = true;
BSSSection = "\t.section\t.bss";
LCOMMDirective = "\t.lcomm\t";
CStringSection = ".rodata.str";
+ FourByteConstantSection = "\t.section\t.rodata.cst4,\"aM\",@progbits,4";
- if (!TM.getSubtarget<MipsSubtarget>().hasABICall())
+ if (!Subtarget->hasABICall()) {
JumpTableDirective = "\t.word\t";
- else
+ SmallDataSection = getNamedSection("\t.sdata", SectionFlags::Writeable);
+ SmallBSSSection = getNamedSection("\t.sbss", SectionFlags::Writeable |
+ SectionFlags::BSS);
+ } else
JumpTableDirective = "\t.gpword\t";
-
- SmallDataSection = getNamedSection("\t.sdata", SectionFlags::Writeable);
- SmallBSSSection = getNamedSection("\t.sbss",
- SectionFlags::Writeable | SectionFlags::BSS);
+
}
SectionKind::Kind
MipsTargetAsmInfo::SectionKindForGlobal(const GlobalValue *GV) const {
SectionKind::Kind K = ELFTargetAsmInfo::SectionKindForGlobal(GV);
+ if (Subtarget->hasABICall())
+ return K;
+
if (K != SectionKind::Data && K != SectionKind::BSS &&
K != SectionKind::RODataMergeConst)
return K;
if (isa<GlobalVariable>(GV)) {
const TargetData *TD = ETM->getTargetData();
unsigned Size = TD->getABITypeSize(GV->getType()->getElementType());
- unsigned Threshold =
- MipsTM->getSubtarget<MipsSubtarget>().getSSectionThreshold();
+ unsigned Threshold = Subtarget->getSSectionThreshold();
if (Size > 0 && Size <= Threshold) {
if (K == SectionKind::BSS)
#ifndef MIPSTARGETASMINFO_H
#define MIPSTARGETASMINFO_H
-#include "llvm/Target/TargetAsmInfo.h"
-#include "llvm/Target/ELFTargetAsmInfo.h"
+#include "MipsSubtarget.h"
#include "llvm/DerivedTypes.h"
#include "llvm/GlobalVariable.h"
+#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetOptions.h"
+#include "llvm/Target/ELFTargetAsmInfo.h"
namespace llvm {
virtual const Section* SelectSectionForGlobal(const GlobalValue *GV) const;
private:
- const MipsTargetMachine *MipsTM;
-
+ const MipsSubtarget *Subtarget;
};
} // namespace llvm