/src/build/lib/Target/Hexagon/HexagonGenCallingConv.inc

Source (jump to first uncovered line)
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Calling Convention Implementation Fragment                                 *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

#ifndef GET_CC_REGISTER_LISTS

static bool CC_Hexagon(unsigned ValNo, MVT ValVT,
                       MVT LocVT, CCValAssign::LocInfo LocInfo,
                       ISD::ArgFlagsTy ArgFlags, CCState &State);
static bool CC_HexagonStack(unsigned ValNo, MVT ValVT,
                            MVT LocVT, CCValAssign::LocInfo LocInfo,
                            ISD::ArgFlagsTy ArgFlags, CCState &State);
static bool CC_Hexagon_HVX(unsigned ValNo, MVT ValVT,
                           MVT LocVT, CCValAssign::LocInfo LocInfo,
                           ISD::ArgFlagsTy ArgFlags, CCState &State);
static bool CC_Hexagon_Legacy(unsigned ValNo, MVT ValVT,
                              MVT LocVT, CCValAssign::LocInfo LocInfo,
                              ISD::ArgFlagsTy ArgFlags, CCState &State);
static bool RetCC_Hexagon(unsigned ValNo, MVT ValVT,
                          MVT LocVT, CCValAssign::LocInfo LocInfo,
                          ISD::ArgFlagsTy ArgFlags, CCState &State);
static bool RetCC_Hexagon_HVX(unsigned ValNo, MVT ValVT,
                              MVT LocVT, CCValAssign::LocInfo LocInfo,
                              ISD::ArgFlagsTy ArgFlags, CCState &State);


static bool CC_Hexagon(unsigned ValNo, MVT ValVT,
                       MVT LocVT, CCValAssign::LocInfo LocInfo,
                       ISD::ArgFlagsTy ArgFlags, CCState &State) {

  if (LocVT == MVT::i1 ||
      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::f32) {
    LocVT = MVT::i32;
    LocInfo = CCValAssign::BCvt;
  }

  if (LocVT == MVT::f64) {
    LocVT = MVT::i64;
    LocInfo = CCValAssign::BCvt;
  }

  if (ArgFlags.isByVal()) {
    State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 8, Align(1), ArgFlags);
    return false;
  }

  if (State.isVarArg() && ValNo >= static_cast<HexagonCCState&>(State).getNumNamedVarArgParams()) {
    if (!CC_HexagonStack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
      return false;
  }

  if (LocVT == MVT::i32) {
    if (ArgFlags.isSplit()) {
      if (CC_SkipOdd(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
        return false;
    }
  }

  if (LocVT == MVT::i32 ||
      LocVT == MVT::v2i16 ||
      LocVT == MVT::v4i8) {
    static const MCPhysReg RegList1[] = {
      Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4, Hexagon::R5
    };
    if (unsigned Reg = State.AllocateReg(RegList1)) {
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      return false;
    }
  }

  if (LocVT == MVT::i64 ||
      LocVT == MVT::v2i32 ||
      LocVT == MVT::v4i16 ||
      LocVT == MVT::v8i8) {
    if (CC_SkipOdd(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
      return false;
  }

  if (LocVT == MVT::i64 ||
      LocVT == MVT::v2i32 ||
      LocVT == MVT::v4i16 ||
      LocVT == MVT::v8i8) {
    static const MCPhysReg RegList2[] = {
      Hexagon::D0, Hexagon::D1, Hexagon::D2
    };
    if (unsigned Reg = State.AllocateReg(RegList2)) {
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      return false;
    }
  }

  if (!CC_HexagonStack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
    return false;

  return true; // CC didn't match.
}


static bool CC_HexagonStack(unsigned ValNo, MVT ValVT,
                            MVT LocVT, CCValAssign::LocInfo LocInfo,
                            ISD::ArgFlagsTy ArgFlags, CCState &State) {

  if (LocVT == MVT::i32 ||
      LocVT == MVT::v2i16 ||
      LocVT == MVT::v4i8) {
    int64_t Offset1 = State.AllocateStack(4, Align(4));
    State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset1, LocVT, LocInfo));
    return false;
  }

  if (LocVT == MVT::i64 ||
      LocVT == MVT::v2i32 ||
      LocVT == MVT::v4i16 ||
      LocVT == MVT::v8i8) {
    int64_t Offset2 = State.AllocateStack(8, Align(8));
    State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset2, LocVT, LocInfo));
    return false;
  }

  return true; // CC didn't match.
}


static bool CC_Hexagon_HVX(unsigned ValNo, MVT ValVT,
                           MVT LocVT, CCValAssign::LocInfo LocInfo,
                           ISD::ArgFlagsTy ArgFlags, CCState &State) {

  if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
    if (LocVT == MVT::v16i32 ||
        LocVT == MVT::v32i16 ||
        LocVT == MVT::v64i8) {
      static const MCPhysReg RegList1[] = {
        Hexagon::V0, Hexagon::V1, Hexagon::V2, Hexagon::V3, Hexagon::V4, Hexagon::V5, Hexagon::V6, Hexagon::V7, Hexagon::V8, Hexagon::V9, Hexagon::V10, Hexagon::V11, Hexagon::V12, Hexagon::V13, Hexagon::V14, Hexagon::V15
      };
      if (unsigned Reg = State.AllocateReg(RegList1)) {
        State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
        return false;
      }
    }
  }

  if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
    if (LocVT == MVT::v32i32 ||
        LocVT == MVT::v64i16 ||
        LocVT == MVT::v128i8) {
      static const MCPhysReg RegList2[] = {
        Hexagon::W0, Hexagon::W1, Hexagon::W2, Hexagon::W3, Hexagon::W4, Hexagon::W5, Hexagon::W6, Hexagon::W7
      };
      if (unsigned Reg = State.AllocateReg(RegList2)) {
        State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
        return false;
      }
    }
  }

  if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
    if (LocVT == MVT::v16i32 ||
        LocVT == MVT::v32i16 ||
        LocVT == MVT::v64i8) {
      int64_t Offset3 = State.AllocateStack(64, Align(64));
      State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset3, LocVT, LocInfo));
      return false;
    }
  }

  if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
    if (LocVT == MVT::v32i32 ||
        LocVT == MVT::v64i16 ||
        LocVT == MVT::v128i8) {
      int64_t Offset4 = State.AllocateStack(128, Align(64));
      State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset4, LocVT, LocInfo));
      return false;
    }
  }

  if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
    if (LocVT == MVT::v32i32 ||
        LocVT == MVT::v64i16 ||
        LocVT == MVT::v128i8 ||
        LocVT == MVT::v32f32 ||
        LocVT == MVT::v64f16) {
      static const MCPhysReg RegList5[] = {
        Hexagon::V0, Hexagon::V1, Hexagon::V2, Hexagon::V3, Hexagon::V4, Hexagon::V5, Hexagon::V6, Hexagon::V7, Hexagon::V8, Hexagon::V9, Hexagon::V10, Hexagon::V11, Hexagon::V12, Hexagon::V13, Hexagon::V14, Hexagon::V15
      };
      if (unsigned Reg = State.AllocateReg(RegList5)) {
        State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
        return false;
      }
    }
  }

  if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
    if (LocVT == MVT::v64i32 ||
        LocVT == MVT::v128i16 ||
        LocVT == MVT::v256i8 ||
        LocVT == MVT::v64f32 ||
        LocVT == MVT::v128f16) {
      static const MCPhysReg RegList6[] = {
        Hexagon::W0, Hexagon::W1, Hexagon::W2, Hexagon::W3, Hexagon::W4, Hexagon::W5, Hexagon::W6, Hexagon::W7
      };
      if (unsigned Reg = State.AllocateReg(RegList6)) {
        State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
        return false;
      }
    }
  }

  if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
    if (LocVT == MVT::v32i32 ||
        LocVT == MVT::v64i16 ||
        LocVT == MVT::v128i8 ||
        LocVT == MVT::v32f32 ||
        LocVT == MVT::v64f16) {
      int64_t Offset7 = State.AllocateStack(128, Align(128));
      State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
      return false;
    }
  }

  if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
    if (LocVT == MVT::v64i32 ||
        LocVT == MVT::v128i16 ||
        LocVT == MVT::v256i8 ||
        LocVT == MVT::v64f32 ||
        LocVT == MVT::v128f16) {
      int64_t Offset8 = State.AllocateStack(256, Align(128));
      State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset8, LocVT, LocInfo));
      return false;
    }
  }

  if (!CC_Hexagon(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
    return false;

  return true; // CC didn't match.
}


static bool CC_Hexagon_Legacy(unsigned ValNo, MVT ValVT,
                              MVT LocVT, CCValAssign::LocInfo LocInfo,
                              ISD::ArgFlagsTy ArgFlags, CCState &State) {

  if (LocVT == MVT::i1 ||
      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::f32) {
    LocVT = MVT::i32;
    LocInfo = CCValAssign::BCvt;
  }

  if (LocVT == MVT::f64) {
    LocVT = MVT::i64;
    LocInfo = CCValAssign::BCvt;
  }

  if (ArgFlags.isByVal()) {
    State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 8, Align(8), ArgFlags);
    return false;
  }

  if (State.isVarArg() && ValNo >= static_cast<HexagonCCState&>(State).getNumNamedVarArgParams()) {
    if (!CC_HexagonStack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
      return false;
  }

  if (LocVT == MVT::i32) {
    if (ArgFlags.isSplit()) {
      if (CC_SkipOdd(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
        return false;
    }
  }

  if (LocVT == MVT::i32 ||
      LocVT == MVT::v2i16 ||
      LocVT == MVT::v4i8) {
    static const MCPhysReg RegList1[] = {
      Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4, Hexagon::R5
    };
    if (unsigned Reg = State.AllocateReg(RegList1)) {
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      return false;
    }
  }

  if (LocVT == MVT::i64 ||
      LocVT == MVT::v2i32 ||
      LocVT == MVT::v4i16 ||
      LocVT == MVT::v8i8) {
    if (CC_SkipOdd(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
      return false;
  }

  if (LocVT == MVT::i64 ||
      LocVT == MVT::v2i32 ||
      LocVT == MVT::v4i16 ||
      LocVT == MVT::v8i8) {
    static const MCPhysReg RegList2[] = {
      Hexagon::D0, Hexagon::D1, Hexagon::D2
    };
    if (unsigned Reg = State.AllocateReg(RegList2)) {
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      return false;
    }
  }

  if (!CC_HexagonStack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
    return false;

  return true; // CC didn't match.
}


static bool RetCC_Hexagon(unsigned ValNo, MVT ValVT,
                          MVT LocVT, CCValAssign::LocInfo LocInfo,
                          ISD::ArgFlagsTy ArgFlags, CCState &State) {

  if (LocVT == MVT::i1 ||
      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::f32) {
    LocVT = MVT::i32;
    LocInfo = CCValAssign::BCvt;
  }

  if (LocVT == MVT::f64) {
    LocVT = MVT::i64;
    LocInfo = CCValAssign::BCvt;
  }

  if (ArgFlags.isSplit()) {
    static const MCPhysReg RegList1[] = {
      Hexagon::R0, Hexagon::R1
    };
    if (unsigned Reg = State.AllocateReg(RegList1)) {
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      return false;
    }
  }

  if (LocVT == MVT::i32 ||
      LocVT == MVT::v2i16 ||
      LocVT == MVT::v4i8) {
    static const MCPhysReg RegList2[] = {
      Hexagon::R0, Hexagon::R1
    };
    if (unsigned Reg = State.AllocateReg(RegList2)) {
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      return false;
    }
  }

  if (LocVT == MVT::i64 ||
      LocVT == MVT::v2i32 ||
      LocVT == MVT::v4i16 ||
      LocVT == MVT::v8i8) {
    if (unsigned Reg = State.AllocateReg(Hexagon::D0)) {
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
      return false;
    }
  }

  return true; // CC didn't match.
}


static bool RetCC_Hexagon_HVX(unsigned ValNo, MVT ValVT,
                              MVT LocVT, CCValAssign::LocInfo LocInfo,
                              ISD::ArgFlagsTy ArgFlags, CCState &State) {

  if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
    if (LocVT == MVT::v16i32 ||
        LocVT == MVT::v32i16 ||
        LocVT == MVT::v64i8) {
      if (unsigned Reg = State.AllocateReg(Hexagon::V0)) {
        State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
        return false;
      }
    }
  }

  if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
    if (LocVT == MVT::v32i32 ||
        LocVT == MVT::v64i16 ||
        LocVT == MVT::v128i8) {
      if (unsigned Reg = State.AllocateReg(Hexagon::W0)) {
        State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
        return false;
      }
    }
  }

  if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
    if (LocVT == MVT::v32i32 ||
        LocVT == MVT::v64i16 ||
        LocVT == MVT::v128i8 ||
        LocVT == MVT::v32f32 ||
        LocVT == MVT::v64f16) {
      if (unsigned Reg = State.AllocateReg(Hexagon::V0)) {
        State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
        return false;
      }
    }
  }

  if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
    if (LocVT == MVT::v64i32 ||
        LocVT == MVT::v128i16 ||
        LocVT == MVT::v256i8 ||
        LocVT == MVT::v64f32 ||
        LocVT == MVT::v128f16) {
      if (unsigned Reg = State.AllocateReg(Hexagon::W0)) {
        State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
        return false;
      }
    }
  }

  if (!RetCC_Hexagon(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
    return false;

  return true; // CC didn't match.
}

#else

const MCRegister CC_Hexagon_ArgRegs[] = { Hexagon::D0, Hexagon::D1, Hexagon::D2, Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4, Hexagon::R5 };
const MCRegister CC_HexagonStack_ArgRegs[] = { 0 };
const MCRegister CC_Hexagon_HVX_ArgRegs[] = { Hexagon::V0, Hexagon::V1, Hexagon::V10, Hexagon::V11, Hexagon::V12, Hexagon::V13, Hexagon::V14, Hexagon::V15, Hexagon::V2, Hexagon::V3, Hexagon::V4, Hexagon::V5, Hexagon::V6, Hexagon::V7, Hexagon::V8, Hexagon::V9, Hexagon::W0, Hexagon::W1, Hexagon::W2, Hexagon::W3, Hexagon::W4, Hexagon::W5, Hexagon::W6, Hexagon::W7 };
const MCRegister CC_Hexagon_Legacy_ArgRegs[] = { Hexagon::D0, Hexagon::D1, Hexagon::D2, Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4, Hexagon::R5 };
const MCRegister RetCC_Hexagon_ArgRegs[] = { Hexagon::D0, Hexagon::R0, Hexagon::R1 };
const MCRegister RetCC_Hexagon_HVX_ArgRegs[] = { Hexagon::V0, Hexagon::W0 };

#endif // CC_REGISTER_LIST

Coverage Report

Created: 2024-01-17 10:31

Line	Count	Source (jump to first uncovered line)
1		/===- TableGen'erated file -------------------------------------- C++ --===\
2		\|* *\|
3		\|* Calling Convention Implementation Fragment *\|
4		\|* *\|
5		\|* Automatically generated file, do not edit! *\|
6		\|* *\|
7		\===----------------------------------------------------------------------===/
8
9		#ifndef GET_CC_REGISTER_LISTS
10
11		static bool CC_Hexagon(unsigned ValNo, MVT ValVT,
12		MVT LocVT, CCValAssign::LocInfo LocInfo,
13		ISD::ArgFlagsTy ArgFlags, CCState &State);
14		static bool CC_HexagonStack(unsigned ValNo, MVT ValVT,
15		MVT LocVT, CCValAssign::LocInfo LocInfo,
16		ISD::ArgFlagsTy ArgFlags, CCState &State);
17		static bool CC_Hexagon_HVX(unsigned ValNo, MVT ValVT,
18		MVT LocVT, CCValAssign::LocInfo LocInfo,
19		ISD::ArgFlagsTy ArgFlags, CCState &State);
20		static bool CC_Hexagon_Legacy(unsigned ValNo, MVT ValVT,
21		MVT LocVT, CCValAssign::LocInfo LocInfo,
22		ISD::ArgFlagsTy ArgFlags, CCState &State);
23		static bool RetCC_Hexagon(unsigned ValNo, MVT ValVT,
24		MVT LocVT, CCValAssign::LocInfo LocInfo,
25		ISD::ArgFlagsTy ArgFlags, CCState &State);
26		static bool RetCC_Hexagon_HVX(unsigned ValNo, MVT ValVT,
27		MVT LocVT, CCValAssign::LocInfo LocInfo,
28		ISD::ArgFlagsTy ArgFlags, CCState &State);
29
30
31		static bool CC_Hexagon(unsigned ValNo, MVT ValVT,
32		MVT LocVT, CCValAssign::LocInfo LocInfo,
33	47.0k	ISD::ArgFlagsTy ArgFlags, CCState &State) {
34
35	47.0k	if (LocVT == MVT::i1 \|\|
36	47.0k	LocVT == MVT::i8 \|\|
37	47.0k	LocVT == MVT::i16) {
38	1.22k	LocVT = MVT::i32;
39	1.22k	if (ArgFlags.isSExt())
40	0	LocInfo = CCValAssign::SExt;
41	1.22k	else if (ArgFlags.isZExt())
42	0	LocInfo = CCValAssign::ZExt;
43	1.22k	else
44	1.22k	LocInfo = CCValAssign::AExt;
45	1.22k	}
46
47	47.0k	if (LocVT == MVT::f32) {
48	6.93k	LocVT = MVT::i32;
49	6.93k	LocInfo = CCValAssign::BCvt;
50	6.93k	}
51
52	47.0k	if (LocVT == MVT::f64) {
53	12.9k	LocVT = MVT::i64;
54	12.9k	LocInfo = CCValAssign::BCvt;
55	12.9k	}
56
57	47.0k	if (ArgFlags.isByVal()) {
58	0	State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 8, Align(1), ArgFlags);
59	0	return false;
60	0	}
61
62	47.0k	if (State.isVarArg() && ValNo >= static_cast<HexagonCCState&>(State).getNumNamedVarArgParams()) {
63	0	if (!CC_HexagonStack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
64	0	return false;
65	0	}
66
67	47.0k	if (LocVT == MVT::i32) {
68	26.1k	if (ArgFlags.isSplit()) {
69	0	if (CC_SkipOdd(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
70	0	return false;
71	0	}
72	26.1k	}
73
74	47.0k	if (LocVT == MVT::i32 \|\|
75	47.0k	LocVT == MVT::v2i16 \|\|
76	47.0k	LocVT == MVT::v4i8) {
77	26.1k	static const MCPhysReg RegList1[] = {
78	26.1k	Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4, Hexagon::R5
79	26.1k	};
80	26.1k	if (unsigned Reg = State.AllocateReg(RegList1)) {
81	23.9k	State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
82	23.9k	return false;
83	23.9k	}
84	26.1k	}
85
86	23.0k	if (LocVT == MVT::i64 \|\|
87	23.0k	LocVT == MVT::v2i32 \|\|
88	23.0k	LocVT == MVT::v4i16 \|\|
89	23.0k	LocVT == MVT::v8i8) {
90	20.8k	if (CC_SkipOdd(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
91	0	return false;
92	20.8k	}
93
94	23.0k	if (LocVT == MVT::i64 \|\|
95	23.0k	LocVT == MVT::v2i32 \|\|
96	23.0k	LocVT == MVT::v4i16 \|\|
97	23.0k	LocVT == MVT::v8i8) {
98	20.8k	static const MCPhysReg RegList2[] = {
99	20.8k	Hexagon::D0, Hexagon::D1, Hexagon::D2
100	20.8k	};
101	20.8k	if (unsigned Reg = State.AllocateReg(RegList2)) {
102	20.5k	State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
103	20.5k	return false;
104	20.5k	}
105	20.8k	}
106
107	2.53k	if (!CC_HexagonStack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
108	2.53k	return false;
109
110	0	return true; // CC didn't match.
111	2.53k	}
112
113
114		static bool CC_HexagonStack(unsigned ValNo, MVT ValVT,
115		MVT LocVT, CCValAssign::LocInfo LocInfo,
116	2.53k	ISD::ArgFlagsTy ArgFlags, CCState &State) {
117
118	2.53k	if (LocVT == MVT::i32 \|\|
119	2.53k	LocVT == MVT::v2i16 \|\|
120	2.53k	LocVT == MVT::v4i8) {
121	2.22k	int64_t Offset1 = State.AllocateStack(4, Align(4));
122	2.22k	State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset1, LocVT, LocInfo));
123	2.22k	return false;
124	2.22k	}
125
126	316	if (LocVT == MVT::i64 \|\|
127	316	LocVT == MVT::v2i32 \|\|
128	316	LocVT == MVT::v4i16 \|\|
129	316	LocVT == MVT::v8i8) {
130	316	int64_t Offset2 = State.AllocateStack(8, Align(8));
131	316	State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset2, LocVT, LocInfo));
132	316	return false;
133	316	}
134
135	0	return true; // CC didn't match.
136	316	}
137
138
139		static bool CC_Hexagon_HVX(unsigned ValNo, MVT ValVT,
140		MVT LocVT, CCValAssign::LocInfo LocInfo,
141	0	ISD::ArgFlagsTy ArgFlags, CCState &State) {
142
143	0	if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
144	0	if (LocVT == MVT::v16i32 \|\|
145	0	LocVT == MVT::v32i16 \|\|
146	0	LocVT == MVT::v64i8) {
147	0	static const MCPhysReg RegList1[] = {
148	0	Hexagon::V0, Hexagon::V1, Hexagon::V2, Hexagon::V3, Hexagon::V4, Hexagon::V5, Hexagon::V6, Hexagon::V7, Hexagon::V8, Hexagon::V9, Hexagon::V10, Hexagon::V11, Hexagon::V12, Hexagon::V13, Hexagon::V14, Hexagon::V15
149	0	};
150	0	if (unsigned Reg = State.AllocateReg(RegList1)) {
151	0	State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
152	0	return false;
153	0	}
154	0	}
155	0	}
156
157	0	if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
158	0	if (LocVT == MVT::v32i32 \|\|
159	0	LocVT == MVT::v64i16 \|\|
160	0	LocVT == MVT::v128i8) {
161	0	static const MCPhysReg RegList2[] = {
162	0	Hexagon::W0, Hexagon::W1, Hexagon::W2, Hexagon::W3, Hexagon::W4, Hexagon::W5, Hexagon::W6, Hexagon::W7
163	0	};
164	0	if (unsigned Reg = State.AllocateReg(RegList2)) {
165	0	State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
166	0	return false;
167	0	}
168	0	}
169	0	}
170
171	0	if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
172	0	if (LocVT == MVT::v16i32 \|\|
173	0	LocVT == MVT::v32i16 \|\|
174	0	LocVT == MVT::v64i8) {
175	0	int64_t Offset3 = State.AllocateStack(64, Align(64));
176	0	State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset3, LocVT, LocInfo));
177	0	return false;
178	0	}
179	0	}
180
181	0	if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
182	0	if (LocVT == MVT::v32i32 \|\|
183	0	LocVT == MVT::v64i16 \|\|
184	0	LocVT == MVT::v128i8) {
185	0	int64_t Offset4 = State.AllocateStack(128, Align(64));
186	0	State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset4, LocVT, LocInfo));
187	0	return false;
188	0	}
189	0	}
190
191	0	if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
192	0	if (LocVT == MVT::v32i32 \|\|
193	0	LocVT == MVT::v64i16 \|\|
194	0	LocVT == MVT::v128i8 \|\|
195	0	LocVT == MVT::v32f32 \|\|
196	0	LocVT == MVT::v64f16) {
197	0	static const MCPhysReg RegList5[] = {
198	0	Hexagon::V0, Hexagon::V1, Hexagon::V2, Hexagon::V3, Hexagon::V4, Hexagon::V5, Hexagon::V6, Hexagon::V7, Hexagon::V8, Hexagon::V9, Hexagon::V10, Hexagon::V11, Hexagon::V12, Hexagon::V13, Hexagon::V14, Hexagon::V15
199	0	};
200	0	if (unsigned Reg = State.AllocateReg(RegList5)) {
201	0	State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
202	0	return false;
203	0	}
204	0	}
205	0	}
206
207	0	if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
208	0	if (LocVT == MVT::v64i32 \|\|
209	0	LocVT == MVT::v128i16 \|\|
210	0	LocVT == MVT::v256i8 \|\|
211	0	LocVT == MVT::v64f32 \|\|
212	0	LocVT == MVT::v128f16) {
213	0	static const MCPhysReg RegList6[] = {
214	0	Hexagon::W0, Hexagon::W1, Hexagon::W2, Hexagon::W3, Hexagon::W4, Hexagon::W5, Hexagon::W6, Hexagon::W7
215	0	};
216	0	if (unsigned Reg = State.AllocateReg(RegList6)) {
217	0	State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
218	0	return false;
219	0	}
220	0	}
221	0	}
222
223	0	if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
224	0	if (LocVT == MVT::v32i32 \|\|
225	0	LocVT == MVT::v64i16 \|\|
226	0	LocVT == MVT::v128i8 \|\|
227	0	LocVT == MVT::v32f32 \|\|
228	0	LocVT == MVT::v64f16) {
229	0	int64_t Offset7 = State.AllocateStack(128, Align(128));
230	0	State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
231	0	return false;
232	0	}
233	0	}
234
235	0	if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
236	0	if (LocVT == MVT::v64i32 \|\|
237	0	LocVT == MVT::v128i16 \|\|
238	0	LocVT == MVT::v256i8 \|\|
239	0	LocVT == MVT::v64f32 \|\|
240	0	LocVT == MVT::v128f16) {
241	0	int64_t Offset8 = State.AllocateStack(256, Align(128));
242	0	State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset8, LocVT, LocInfo));
243	0	return false;
244	0	}
245	0	}
246
247	0	if (!CC_Hexagon(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
248	0	return false;
249
250	0	return true; // CC didn't match.
251	0	}
252
253
254		static bool CC_Hexagon_Legacy(unsigned ValNo, MVT ValVT,
255		MVT LocVT, CCValAssign::LocInfo LocInfo,
256	0	ISD::ArgFlagsTy ArgFlags, CCState &State) {
257
258	0	if (LocVT == MVT::i1 \|\|
259	0	LocVT == MVT::i8 \|\|
260	0	LocVT == MVT::i16) {
261	0	LocVT = MVT::i32;
262	0	if (ArgFlags.isSExt())
263	0	LocInfo = CCValAssign::SExt;
264	0	else if (ArgFlags.isZExt())
265	0	LocInfo = CCValAssign::ZExt;
266	0	else
267	0	LocInfo = CCValAssign::AExt;
268	0	}
269
270	0	if (LocVT == MVT::f32) {
271	0	LocVT = MVT::i32;
272	0	LocInfo = CCValAssign::BCvt;
273	0	}
274
275	0	if (LocVT == MVT::f64) {
276	0	LocVT = MVT::i64;
277	0	LocInfo = CCValAssign::BCvt;
278	0	}
279
280	0	if (ArgFlags.isByVal()) {
281	0	State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 8, Align(8), ArgFlags);
282	0	return false;
283	0	}
284
285	0	if (State.isVarArg() && ValNo >= static_cast<HexagonCCState&>(State).getNumNamedVarArgParams()) {
286	0	if (!CC_HexagonStack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
287	0	return false;
288	0	}
289
290	0	if (LocVT == MVT::i32) {
291	0	if (ArgFlags.isSplit()) {
292	0	if (CC_SkipOdd(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
293	0	return false;
294	0	}
295	0	}
296
297	0	if (LocVT == MVT::i32 \|\|
298	0	LocVT == MVT::v2i16 \|\|
299	0	LocVT == MVT::v4i8) {
300	0	static const MCPhysReg RegList1[] = {
301	0	Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4, Hexagon::R5
302	0	};
303	0	if (unsigned Reg = State.AllocateReg(RegList1)) {
304	0	State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
305	0	return false;
306	0	}
307	0	}
308
309	0	if (LocVT == MVT::i64 \|\|
310	0	LocVT == MVT::v2i32 \|\|
311	0	LocVT == MVT::v4i16 \|\|
312	0	LocVT == MVT::v8i8) {
313	0	if (CC_SkipOdd(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
314	0	return false;
315	0	}
316
317	0	if (LocVT == MVT::i64 \|\|
318	0	LocVT == MVT::v2i32 \|\|
319	0	LocVT == MVT::v4i16 \|\|
320	0	LocVT == MVT::v8i8) {
321	0	static const MCPhysReg RegList2[] = {
322	0	Hexagon::D0, Hexagon::D1, Hexagon::D2
323	0	};
324	0	if (unsigned Reg = State.AllocateReg(RegList2)) {
325	0	State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
326	0	return false;
327	0	}
328	0	}
329
330	0	if (!CC_HexagonStack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
331	0	return false;
332
333	0	return true; // CC didn't match.
334	0	}
335
336
337		static bool RetCC_Hexagon(unsigned ValNo, MVT ValVT,
338		MVT LocVT, CCValAssign::LocInfo LocInfo,
339	44.5k	ISD::ArgFlagsTy ArgFlags, CCState &State) {
340
341	44.5k	if (LocVT == MVT::i1 \|\|
342	44.5k	LocVT == MVT::i8 \|\|
343	44.5k	LocVT == MVT::i16) {
344	4.07k	LocVT = MVT::i32;
345	4.07k	if (ArgFlags.isSExt())
346	0	LocInfo = CCValAssign::SExt;
347	4.07k	else if (ArgFlags.isZExt())
348	0	LocInfo = CCValAssign::ZExt;
349	4.07k	else
350	4.07k	LocInfo = CCValAssign::AExt;
351	4.07k	}
352
353	44.5k	if (LocVT == MVT::f32) {
354	3.95k	LocVT = MVT::i32;
355	3.95k	LocInfo = CCValAssign::BCvt;
356	3.95k	}
357
358	44.5k	if (LocVT == MVT::f64) {
359	11.4k	LocVT = MVT::i64;
360	11.4k	LocInfo = CCValAssign::BCvt;
361	11.4k	}
362
363	44.5k	if (ArgFlags.isSplit()) {
364	0	static const MCPhysReg RegList1[] = {
365	0	Hexagon::R0, Hexagon::R1
366	0	};
367	0	if (unsigned Reg = State.AllocateReg(RegList1)) {
368	0	State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
369	0	return false;
370	0	}
371	0	}
372
373	44.5k	if (LocVT == MVT::i32 \|\|
374	44.5k	LocVT == MVT::v2i16 \|\|
375	44.5k	LocVT == MVT::v4i8) {
376	27.7k	static const MCPhysReg RegList2[] = {
377	27.7k	Hexagon::R0, Hexagon::R1
378	27.7k	};
379	27.7k	if (unsigned Reg = State.AllocateReg(RegList2)) {
380	27.7k	State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
381	27.7k	return false;
382	27.7k	}
383	27.7k	}
384
385	16.7k	if (LocVT == MVT::i64 \|\|
386	16.7k	LocVT == MVT::v2i32 \|\|
387	16.7k	LocVT == MVT::v4i16 \|\|
388	16.7k	LocVT == MVT::v8i8) {
389	16.7k	if (unsigned Reg = State.AllocateReg(Hexagon::D0)) {
390	16.7k	State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
391	16.7k	return false;
392	16.7k	}
393	16.7k	}
394
395	0	return true; // CC didn't match.
396	16.7k	}
397
398
399		static bool RetCC_Hexagon_HVX(unsigned ValNo, MVT ValVT,
400		MVT LocVT, CCValAssign::LocInfo LocInfo,
401	0	ISD::ArgFlagsTy ArgFlags, CCState &State) {
402
403	0	if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
404	0	if (LocVT == MVT::v16i32 \|\|
405	0	LocVT == MVT::v32i16 \|\|
406	0	LocVT == MVT::v64i8) {
407	0	if (unsigned Reg = State.AllocateReg(Hexagon::V0)) {
408	0	State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
409	0	return false;
410	0	}
411	0	}
412	0	}
413
414	0	if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
415	0	if (LocVT == MVT::v32i32 \|\|
416	0	LocVT == MVT::v64i16 \|\|
417	0	LocVT == MVT::v128i8) {
418	0	if (unsigned Reg = State.AllocateReg(Hexagon::W0)) {
419	0	State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
420	0	return false;
421	0	}
422	0	}
423	0	}
424
425	0	if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
426	0	if (LocVT == MVT::v32i32 \|\|
427	0	LocVT == MVT::v64i16 \|\|
428	0	LocVT == MVT::v128i8 \|\|
429	0	LocVT == MVT::v32f32 \|\|
430	0	LocVT == MVT::v64f16) {
431	0	if (unsigned Reg = State.AllocateReg(Hexagon::V0)) {
432	0	State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
433	0	return false;
434	0	}
435	0	}
436	0	}
437
438	0	if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
439	0	if (LocVT == MVT::v64i32 \|\|
440	0	LocVT == MVT::v128i16 \|\|
441	0	LocVT == MVT::v256i8 \|\|
442	0	LocVT == MVT::v64f32 \|\|
443	0	LocVT == MVT::v128f16) {
444	0	if (unsigned Reg = State.AllocateReg(Hexagon::W0)) {
445	0	State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
446	0	return false;
447	0	}
448	0	}
449	0	}
450
451	0	if (!RetCC_Hexagon(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
452	0	return false;
453
454	0	return true; // CC didn't match.
455	0	}
456
457		#else
458
459		const MCRegister CC_Hexagon_ArgRegs[] = { Hexagon::D0, Hexagon::D1, Hexagon::D2, Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4, Hexagon::R5 };
460		const MCRegister CC_HexagonStack_ArgRegs[] = { 0 };
461		const MCRegister CC_Hexagon_HVX_ArgRegs[] = { Hexagon::V0, Hexagon::V1, Hexagon::V10, Hexagon::V11, Hexagon::V12, Hexagon::V13, Hexagon::V14, Hexagon::V15, Hexagon::V2, Hexagon::V3, Hexagon::V4, Hexagon::V5, Hexagon::V6, Hexagon::V7, Hexagon::V8, Hexagon::V9, Hexagon::W0, Hexagon::W1, Hexagon::W2, Hexagon::W3, Hexagon::W4, Hexagon::W5, Hexagon::W6, Hexagon::W7 };
462		const MCRegister CC_Hexagon_Legacy_ArgRegs[] = { Hexagon::D0, Hexagon::D1, Hexagon::D2, Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4, Hexagon::R5 };
463		const MCRegister RetCC_Hexagon_ArgRegs[] = { Hexagon::D0, Hexagon::R0, Hexagon::R1 };
464		const MCRegister RetCC_Hexagon_HVX_ArgRegs[] = { Hexagon::V0, Hexagon::W0 };
465
466		#endif // CC_REGISTER_LIST