open-dsi
/
clamav
mirror of https://github.com/Cisco-Talos/clamav
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ClamAV is an open source (GPLv2) anti-virus toolkit.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5373 Commits
40 Branches
228 Tags
220 MiB
 
 
 
 
 
 
Tag: Branch: Tree: a9fe8977e7
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'a9fe8977e7'
${ noResults }
clamav/libclamav/c++/ARMGenCallingConv.inc

470 lines
13 KiB
Raw Blame History

//===- TableGen'erated file -------------------------------------*- C++ -*-===//
//
// Calling Convention Implementation Fragment
//
// Automatically generated file, do not edit!
//
//===----------------------------------------------------------------------===//
static bool CC_ARM_AAPCS(unsigned ValNo, EVT ValVT,
EVT LocVT, CCValAssign::LocInfo LocInfo,
ISD::ArgFlagsTy ArgFlags, CCState &State);
static bool CC_ARM_AAPCS_Common(unsigned ValNo, EVT ValVT,
EVT LocVT, CCValAssign::LocInfo LocInfo,
ISD::ArgFlagsTy ArgFlags, CCState &State);
static bool CC_ARM_AAPCS_VFP(unsigned ValNo, EVT ValVT,
EVT LocVT, CCValAssign::LocInfo LocInfo,
ISD::ArgFlagsTy ArgFlags, CCState &State);
static bool CC_ARM_APCS(unsigned ValNo, EVT ValVT,
EVT LocVT, CCValAssign::LocInfo LocInfo,
ISD::ArgFlagsTy ArgFlags, CCState &State);
static bool RetCC_ARM_AAPCS(unsigned ValNo, EVT ValVT,
EVT LocVT, CCValAssign::LocInfo LocInfo,
ISD::ArgFlagsTy ArgFlags, CCState &State);
static bool RetCC_ARM_AAPCS_Common(unsigned ValNo, EVT ValVT,
EVT LocVT, CCValAssign::LocInfo LocInfo,
ISD::ArgFlagsTy ArgFlags, CCState &State);
static bool RetCC_ARM_AAPCS_VFP(unsigned ValNo, EVT ValVT,
EVT LocVT, CCValAssign::LocInfo LocInfo,
ISD::ArgFlagsTy ArgFlags, CCState &State);
static bool RetCC_ARM_APCS(unsigned ValNo, EVT ValVT,
EVT LocVT, CCValAssign::LocInfo LocInfo,
ISD::ArgFlagsTy ArgFlags, CCState &State);
static bool CC_ARM_AAPCS(unsigned ValNo, EVT ValVT,
EVT LocVT, CCValAssign::LocInfo LocInfo,
ISD::ArgFlagsTy ArgFlags, CCState &State) {
if (LocVT == MVT::v1i64 ||
LocVT == MVT::v2i32 ||
LocVT == MVT::v4i16 ||
LocVT == MVT::v8i8 ||
LocVT == MVT::v2f32) {
LocVT = MVT::f64;
LocInfo = CCValAssign::BCvt;
}
if (LocVT == MVT::v2i64 ||
LocVT == MVT::v4i32 ||
LocVT == MVT::v8i16 ||
LocVT == MVT::v16i8 ||
LocVT == MVT::v4f32) {
LocVT = MVT::v2f64;
LocInfo = CCValAssign::BCvt;
}
if (LocVT == MVT::f64 ||
LocVT == MVT::v2f64) {
if (CC_ARM_AAPCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
return false;
}
if (LocVT == MVT::f32) {
LocVT = MVT::i32;
LocInfo = CCValAssign::BCvt;
}
if (!CC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
return false;
return true; // CC didn't match.
}
static bool CC_ARM_AAPCS_Common(unsigned ValNo, EVT ValVT,
EVT LocVT, CCValAssign::LocInfo LocInfo,
ISD::ArgFlagsTy ArgFlags, CCState &State) {
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;
}
if (LocVT == MVT::i32) {
if (ArgFlags.getOrigAlign() == 8) {
static const unsigned RegList1[] = {
ARM::R0, ARM::R2
};
static const unsigned RegList2[] = {
ARM::R0, ARM::R1
};
if (unsigned Reg = State.AllocateReg(RegList1, RegList2, 2)) {
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
return false;
}
}
}
if (LocVT == MVT::i32) {
if (State.getNextStackOffset() == 0 &&ArgFlags.getOrigAlign() != 8) {
static const unsigned RegList3[] = {
ARM::R0, ARM::R1, ARM::R2, ARM::R3
};
if (unsigned Reg = State.AllocateReg(RegList3, 4)) {
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
return false;
}
}
}
if (LocVT == MVT::i32) {
if (ArgFlags.getOrigAlign() == 8) {
unsigned Offset4 = State.AllocateStack(4, 8);
State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset4, LocVT, LocInfo));
return false;
}
}
if (LocVT == MVT::i32 ||
LocVT == MVT::f32) {
unsigned Offset5 = State.AllocateStack(4, 4);
State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo));
return false;
}
if (LocVT == MVT::f64) {
unsigned Offset6 = State.AllocateStack(8, 8);
State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset6, LocVT, LocInfo));
return false;
}
if (LocVT == MVT::v2f64) {
unsigned Offset7 = State.AllocateStack(16, 8);
State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
return false;
}
return true; // CC didn't match.
}
static bool CC_ARM_AAPCS_VFP(unsigned ValNo, EVT ValVT,
EVT LocVT, CCValAssign::LocInfo LocInfo,
ISD::ArgFlagsTy ArgFlags, CCState &State) {
if (LocVT == MVT::v1i64 ||
LocVT == MVT::v2i32 ||
LocVT == MVT::v4i16 ||
LocVT == MVT::v8i8 ||
LocVT == MVT::v2f32) {
LocVT = MVT::f64;
LocInfo = CCValAssign::BCvt;
}
if (LocVT == MVT::v2i64 ||
LocVT == MVT::v4i32 ||
LocVT == MVT::v8i16 ||
LocVT == MVT::v16i8 ||
LocVT == MVT::v4f32) {
LocVT = MVT::v2f64;
LocInfo = CCValAssign::BCvt;
}
if (LocVT == MVT::v2f64) {
static const unsigned RegList1[] = {
ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
};
if (unsigned Reg = State.AllocateReg(RegList1, 4)) {
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
return false;
}
}
if (LocVT == MVT::f64) {
static const unsigned RegList2[] = {
ARM::D0, ARM::D1, ARM::D2, ARM::D3, ARM::D4, ARM::D5, ARM::D6, ARM::D7
};
if (unsigned Reg = State.AllocateReg(RegList2, 8)) {
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
return false;
}
}
if (LocVT == MVT::f32) {
static const unsigned RegList3[] = {
ARM::S0, ARM::S1, ARM::S2, ARM::S3, ARM::S4, ARM::S5, ARM::S6, ARM::S7, ARM::S8, ARM::S9, ARM::S10, ARM::S11, ARM::S12, ARM::S13, ARM::S14, ARM::S15
};
if (unsigned Reg = State.AllocateReg(RegList3, 16)) {
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
return false;
}
}
if (!CC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
return false;
return true; // CC didn't match.
}
static bool CC_ARM_APCS(unsigned ValNo, EVT ValVT,
EVT LocVT, CCValAssign::LocInfo LocInfo,
ISD::ArgFlagsTy ArgFlags, CCState &State) {
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;
}
if (LocVT == MVT::v1i64 ||
LocVT == MVT::v2i32 ||
LocVT == MVT::v4i16 ||
LocVT == MVT::v8i8 ||
LocVT == MVT::v2f32) {
LocVT = MVT::f64;
LocInfo = CCValAssign::BCvt;
}
if (LocVT == MVT::v2i64 ||
LocVT == MVT::v4i32 ||
LocVT == MVT::v8i16 ||
LocVT == MVT::v16i8 ||
LocVT == MVT::v4f32) {
LocVT = MVT::v2f64;
LocInfo = CCValAssign::BCvt;
}
if (LocVT == MVT::f64 ||
LocVT == MVT::v2f64) {
if (CC_ARM_APCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
return false;
}
if (LocVT == MVT::f32) {
LocVT = MVT::i32;
LocInfo = CCValAssign::BCvt;
}
if (LocVT == MVT::i32) {
static const unsigned RegList1[] = {
ARM::R0, ARM::R1, ARM::R2, ARM::R3
};
if (unsigned Reg = State.AllocateReg(RegList1, 4)) {
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
return false;
}
}
if (LocVT == MVT::i32) {
unsigned Offset2 = State.AllocateStack(4, 4);
State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset2, LocVT, LocInfo));
return false;
}
if (LocVT == MVT::f64) {
unsigned Offset3 = State.AllocateStack(8, 4);
State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset3, LocVT, LocInfo));
return false;
}
if (LocVT == MVT::v2f64) {
unsigned Offset4 = State.AllocateStack(16, 4);
State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset4, LocVT, LocInfo));
return false;
}
return true; // CC didn't match.
}
static bool RetCC_ARM_AAPCS(unsigned ValNo, EVT ValVT,
EVT LocVT, CCValAssign::LocInfo LocInfo,
ISD::ArgFlagsTy ArgFlags, CCState &State) {
if (LocVT == MVT::v1i64 ||
LocVT == MVT::v2i32 ||
LocVT == MVT::v4i16 ||
LocVT == MVT::v8i8 ||
LocVT == MVT::v2f32) {
LocVT = MVT::f64;
LocInfo = CCValAssign::BCvt;
}
if (LocVT == MVT::v2i64 ||
LocVT == MVT::v4i32 ||
LocVT == MVT::v8i16 ||
LocVT == MVT::v16i8 ||
LocVT == MVT::v4f32) {
LocVT = MVT::v2f64;
LocInfo = CCValAssign::BCvt;
}
if (LocVT == MVT::f64 ||
LocVT == MVT::v2f64) {
if (RetCC_ARM_AAPCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
return false;
}
if (LocVT == MVT::f32) {
LocVT = MVT::i32;
LocInfo = CCValAssign::BCvt;
}
if (!RetCC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
return false;
return true; // CC didn't match.
}
static bool RetCC_ARM_AAPCS_Common(unsigned ValNo, EVT ValVT,
EVT LocVT, CCValAssign::LocInfo LocInfo,
ISD::ArgFlagsTy ArgFlags, CCState &State) {
if (LocVT == MVT::i32) {
static const unsigned RegList1[] = {
ARM::R0, ARM::R1, ARM::R2, ARM::R3
};
if (unsigned Reg = State.AllocateReg(RegList1, 4)) {
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
return false;
}
}
if (LocVT == MVT::i64) {
static const unsigned RegList2[] = {
ARM::R0, ARM::R2
};
static const unsigned RegList3[] = {
ARM::R1, ARM::R3
};
if (unsigned Reg = State.AllocateReg(RegList2, RegList3, 2)) {
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
return false;
}
}
return true; // CC didn't match.
}
static bool RetCC_ARM_AAPCS_VFP(unsigned ValNo, EVT ValVT,
EVT LocVT, CCValAssign::LocInfo LocInfo,
ISD::ArgFlagsTy ArgFlags, CCState &State) {
if (LocVT == MVT::v1i64 ||
LocVT == MVT::v2i32 ||
LocVT == MVT::v4i16 ||
LocVT == MVT::v8i8 ||
LocVT == MVT::v2f32) {
LocVT = MVT::f64;
LocInfo = CCValAssign::BCvt;
}
if (LocVT == MVT::v2i64 ||
LocVT == MVT::v4i32 ||
LocVT == MVT::v8i16 ||
LocVT == MVT::v16i8 ||
LocVT == MVT::v4f32) {
LocVT = MVT::v2f64;
LocInfo = CCValAssign::BCvt;
}
if (LocVT == MVT::v2f64) {
static const unsigned RegList1[] = {
ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
};
if (unsigned Reg = State.AllocateReg(RegList1, 4)) {
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
return false;
}
}
if (LocVT == MVT::f64) {
static const unsigned RegList2[] = {
ARM::D0, ARM::D1, ARM::D2, ARM::D3, ARM::D4, ARM::D5, ARM::D6, ARM::D7
};
if (unsigned Reg = State.AllocateReg(RegList2, 8)) {
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
return false;
}
}
if (LocVT == MVT::f32) {
static const unsigned RegList3[] = {
ARM::S0, ARM::S1, ARM::S2, ARM::S3, ARM::S4, ARM::S5, ARM::S6, ARM::S7, ARM::S8, ARM::S9, ARM::S10, ARM::S11, ARM::S12, ARM::S13, ARM::S14, ARM::S15
};
if (unsigned Reg = State.AllocateReg(RegList3, 16)) {
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
return false;
}
}
if (!RetCC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
return false;
return true; // CC didn't match.
}
static bool RetCC_ARM_APCS(unsigned ValNo, EVT ValVT,
EVT LocVT, CCValAssign::LocInfo LocInfo,
ISD::ArgFlagsTy ArgFlags, CCState &State) {
if (LocVT == MVT::f32) {
LocVT = MVT::i32;
LocInfo = CCValAssign::BCvt;
}
if (LocVT == MVT::v1i64 ||
LocVT == MVT::v2i32 ||
LocVT == MVT::v4i16 ||
LocVT == MVT::v8i8 ||
LocVT == MVT::v2f32) {
LocVT = MVT::f64;
LocInfo = CCValAssign::BCvt;
}
if (LocVT == MVT::v2i64 ||
LocVT == MVT::v4i32 ||
LocVT == MVT::v8i16 ||
LocVT == MVT::v16i8 ||
LocVT == MVT::v4f32) {
LocVT = MVT::v2f64;
LocInfo = CCValAssign::BCvt;
}
if (LocVT == MVT::f64 ||
LocVT == MVT::v2f64) {
if (RetCC_ARM_APCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
return false;
}
if (LocVT == MVT::i32) {
static const unsigned RegList1[] = {
ARM::R0, ARM::R1, ARM::R2, ARM::R3
};
if (unsigned Reg = State.AllocateReg(RegList1, 4)) {
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
return false;
}
}
if (LocVT == MVT::i64) {
static const unsigned RegList2[] = {
ARM::R0, ARM::R2
};
static const unsigned RegList3[] = {
ARM::R1, ARM::R3
};
if (unsigned Reg = State.AllocateReg(RegList2, RegList3, 2)) {
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
return false;
}
}
return true; // CC didn't match.
}