def HasPolicyOperand : Policy<2>;
class RVVBuiltin<string suffix, string prototype, string type_range,
- string mangled_suffix = ""> {
+ string overloaded_suffix = ""> {
// Base name that will be prepended in __builtin_rvv_ and appended the
// computed Suffix.
string Name = NAME;
// underscore (_). It is instantiated like Prototype.
string Suffix = suffix;
- // If empty, default MangledName is sub string of `Name` which end of first
- // '_'. For example, the default mangled name is `vadd` for Name `vadd_vv`.
+ // If empty, default OverloadedName is sub string of `Name` which end of first
+ // '_'. For example, the default overloaded name is `vadd` for Name `vadd_vv`.
// It's used for describe some special naming cases.
- string MangledName = "";
+ string OverloadedName = "";
- // If not empty, each MangledName will have this appended after an
+ // If not empty, each OverloadedName will have this appended after an
// underscore (_). It is instantiated like Prototype.
- string MangledSuffix = mangled_suffix;
+ string OverloadedSuffix = overloaded_suffix;
// The different variants of the builtin, parameterised with a type.
string TypeRange = type_range;
: RVVBuiltin<suffix, prototype, type_range> {
let IRName = intrinsic_name;
let MaskedIRName = intrinsic_name # "_mask";
- let MangledName = NAME;
+ let OverloadedName = NAME;
let IntrinsicTypes = [-1, 0];
}
class RVVFloatingUnaryVVBuiltin : RVVFloatingUnaryBuiltin<"v", "v", "vv">;
class RVVConvBuiltin<string suffix, string prototype, string type_range,
- string mangled_name>
+ string overloaded_name>
: RVVBuiltin<suffix, prototype, type_range> {
let IntrinsicTypes = [-1, 0];
- let MangledName = mangled_name;
+ let OverloadedName = overloaded_name;
}
-class RVVConvToSignedBuiltin<string mangled_name>
- : RVVConvBuiltin<"Iv", "Ivv", "xfd", mangled_name>;
+class RVVConvToSignedBuiltin<string overloaded_name>
+ : RVVConvBuiltin<"Iv", "Ivv", "xfd", overloaded_name>;
-class RVVConvToUnsignedBuiltin<string mangled_name>
- : RVVConvBuiltin<"Uv", "Uvv", "xfd", mangled_name>;
+class RVVConvToUnsignedBuiltin<string overloaded_name>
+ : RVVConvBuiltin<"Uv", "Uvv", "xfd", overloaded_name>;
-class RVVConvToWidenSignedBuiltin<string mangled_name>
- : RVVConvBuiltin<"Iw", "Iwv", "xf", mangled_name>;
+class RVVConvToWidenSignedBuiltin<string overloaded_name>
+ : RVVConvBuiltin<"Iw", "Iwv", "xf", overloaded_name>;
-class RVVConvToWidenUnsignedBuiltin<string mangled_name>
- : RVVConvBuiltin<"Uw", "Uwv", "xf", mangled_name>;
+class RVVConvToWidenUnsignedBuiltin<string overloaded_name>
+ : RVVConvBuiltin<"Uw", "Uwv", "xf", overloaded_name>;
-class RVVConvToNarrowingSignedBuiltin<string mangled_name>
- : RVVConvBuiltin<"Iv", "IvFw", "csi", mangled_name>;
+class RVVConvToNarrowingSignedBuiltin<string overloaded_name>
+ : RVVConvBuiltin<"Iv", "IvFw", "csi", overloaded_name>;
-class RVVConvToNarrowingUnsignedBuiltin<string mangled_name>
- : RVVConvBuiltin<"Uv", "UvFw", "csi", mangled_name>;
+class RVVConvToNarrowingUnsignedBuiltin<string overloaded_name>
+ : RVVConvBuiltin<"Uv", "UvFw", "csi", overloaded_name>;
let HasMaskedOffOperand = false in {
multiclass RVVSignedReductionBuiltin {
IRName = intrinsic_name, MaskedIRName = intrinsic_name # "_mask" in {
foreach s_p = suffixes_prototypes in {
let Name = NAME # "_" # s_p[0],
- MangledName = NAME # "_" # s_p[0] in {
+ OverloadedName = NAME # "_" # s_p[0] in {
defvar suffix = s_p[1];
defvar prototype = s_p[2];
def : RVVOutOp0Op1Builtin<suffix, prototype, type_range>;
IRName = intrinsic_name, MaskedIRName = intrinsic_name # "_mask" in {
foreach s_p = suffixes_prototypes in {
let Name = NAME # "_" # s_p[0],
- MangledName = NAME # "_" # s_p[0] in {
+ OverloadedName = NAME # "_" # s_p[0] in {
defvar suffix = s_p[1];
defvar prototype = s_p[2];
def : RVVOutOp1Builtin<suffix, prototype, type_range>;
multiclass RVVPseudoVWCVTBuiltin<string IR, string MName, string type_range,
list<list<string>> suffixes_prototypes> {
let Name = NAME,
- MangledName = MName,
+ OverloadedName = MName,
IRName = IR,
MaskedIRName = IR # "_mask",
ManualCodegen = [{
multiclass RVVPseudoVNCVTBuiltin<string IR, string MName, string type_range,
list<list<string>> suffixes_prototypes> {
let Name = NAME,
- MangledName = MName,
+ OverloadedName = MName,
IRName = IR,
MaskedIRName = IR # "_mask",
ManualCodegen = [{
// 12.16. Vector Integer Move Instructions
let HasMasked = false, UnMaskedPolicy = HasPassthruOperand, MaskedPolicy = NonePolicy in {
- let MangledName = "vmv_v" in {
+ let OverloadedName = "vmv_v" in {
defm vmv_v : RVVOutBuiltinSet<"vmv_v_v", "csil",
[["v", "Uv", "UvUv"]]>;
defm vmv_v : RVVOutBuiltinSet<"vmv_v_v", "csilxfd",
// 17. Vector Permutation Instructions
// 17.1. Integer Scalar Move Instructions
let HasMasked = false, MaskedPolicy = NonePolicy in {
- let HasVL = false, MangledName = "vmv_x" in
+ let HasVL = false, OverloadedName = "vmv_x" in
defm vmv_x : RVVOp0BuiltinSet<"vmv_x_s", "csil",
[["s", "ve", "ev"],
["s", "UvUe", "UeUv"]]>;
- let MangledName = "vmv_s" in
+ let OverloadedName = "vmv_s" in
defm vmv_s : RVVOutBuiltinSet<"vmv_s_x", "csil",
[["x", "v", "vve"],
["x", "Uv", "UvUvUe"]]>;
// 17.2. Floating-Point Scalar Move Instructions
let HasMasked = false, MaskedPolicy = NonePolicy in {
- let HasVL = false, MangledName = "vfmv_f" in
+ let HasVL = false, OverloadedName = "vfmv_f" in
defm vfmv_f : RVVOp0BuiltinSet<"vfmv_f_s", "xfd",
[["s", "ve", "ev"]]>;
- let MangledName = "vfmv_s" in
+ let OverloadedName = "vfmv_s" in
defm vfmv_s : RVVOutBuiltinSet<"vfmv_s_f", "xfd",
[["f", "v", "vve"],
["x", "Uv", "UvUvUe"]]>;
// LMUL truncation
// C/C++ Operand: VecTy, IR Operand: VecTy, Index
- let Name = "vlmul_trunc_v", MangledName = "vlmul_trunc", MaskedPolicy = NonePolicy,
+ let Name = "vlmul_trunc_v", OverloadedName = "vlmul_trunc", MaskedPolicy = NonePolicy,
ManualCodegen = [{ {
ID = Intrinsic::experimental_vector_extract;
IntrinsicTypes = {ResultType, Ops[0]->getType()};
// LMUL extension
// C/C++ Operand: SubVecTy, IR Operand: VecTy, SubVecTy, Index
- let Name = "vlmul_ext_v", MangledName = "vlmul_ext", MaskedPolicy = NonePolicy,
+ let Name = "vlmul_ext_v", OverloadedName = "vlmul_ext", MaskedPolicy = NonePolicy,
ManualCodegen = [{
ID = Intrinsic::experimental_vector_insert;
IntrinsicTypes = {ResultType, Ops[0]->getType()};
/// have illegal RVVType.
static llvm::Optional<RVVTypes>
computeTypes(BasicType BT, int Log2LMUL, unsigned NF,
- llvm::ArrayRef<PrototypeDescriptor> PrototypeSeq);
+ llvm::ArrayRef<PrototypeDescriptor> Prototype);
static llvm::Optional<RVVTypePtr> computeType(BasicType BT, int Log2LMUL,
PrototypeDescriptor Proto);
};
private:
std::string BuiltinName; // Builtin name
std::string Name; // C intrinsic name.
- std::string MangledName;
+ std::string OverloadedName;
std::string IRName;
bool IsMasked;
bool HasVL;
unsigned NF = 1;
public:
- RVVIntrinsic(llvm::StringRef Name, llvm::StringRef Suffix, llvm::StringRef MangledName,
- llvm::StringRef MangledSuffix, llvm::StringRef IRName, bool IsMasked,
- bool HasMaskedOffOperand, bool HasVL, PolicyScheme Scheme,
- bool HasUnMaskedOverloaded, bool HasBuiltinAlias,
- llvm::StringRef ManualCodegen, const RVVTypes &Types,
+ RVVIntrinsic(llvm::StringRef Name, llvm::StringRef Suffix,
+ llvm::StringRef OverloadedName, llvm::StringRef OverloadedSuffix,
+ llvm::StringRef IRName, bool IsMasked, bool HasMaskedOffOperand,
+ bool HasVL, PolicyScheme Scheme, bool HasUnMaskedOverloaded,
+ bool HasBuiltinAlias, llvm::StringRef ManualCodegen,
+ const RVVTypes &Types,
const std::vector<int64_t> &IntrinsicTypes,
- const std::vector<llvm::StringRef> &RequiredFeatures, unsigned NF);
+ const std::vector<llvm::StringRef> &RequiredFeatures,
+ unsigned NF);
~RVVIntrinsic() = default;
RVVTypePtr getOutputType() const { return OutputType; }
const RVVTypes &getInputTypes() const { return InputTypes; }
llvm::StringRef getBuiltinName() const { return BuiltinName; }
llvm::StringRef getName() const { return Name; }
- llvm::StringRef getMangledName() const { return MangledName; }
+ llvm::StringRef getOverloadedName() const { return OverloadedName; }
bool hasVL() const { return HasVL; }
bool hasPolicy() const { return Scheme != SchemeNone; }
bool hasPassthruOperand() const { return Scheme == HasPassthruOperand; }
Optional<RVVTypes>
RVVType::computeTypes(BasicType BT, int Log2LMUL, unsigned NF,
- ArrayRef<PrototypeDescriptor> PrototypeSeq) {
+ ArrayRef<PrototypeDescriptor> Prototype) {
// LMUL x NF must be less than or equal to 8.
if ((Log2LMUL >= 1) && (1 << Log2LMUL) * NF > 8)
return llvm::None;
RVVTypes Types;
- for (const PrototypeDescriptor &Proto : PrototypeSeq) {
+ for (const PrototypeDescriptor &Proto : Prototype) {
auto T = computeType(BT, Log2LMUL, Proto);
if (!T.hasValue())
return llvm::None;
// RVVIntrinsic implementation
//===----------------------------------------------------------------------===//
RVVIntrinsic::RVVIntrinsic(
- StringRef NewName, StringRef Suffix, StringRef NewMangledName,
- StringRef MangledSuffix, StringRef IRName, bool IsMasked,
+ StringRef NewName, StringRef Suffix, StringRef NewOverloadedName,
+ StringRef OverloadedSuffix, StringRef IRName, bool IsMasked,
bool HasMaskedOffOperand, bool HasVL, PolicyScheme Scheme,
bool HasUnMaskedOverloaded, bool HasBuiltinAlias, StringRef ManualCodegen,
const RVVTypes &OutInTypes, const std::vector<int64_t> &NewIntrinsicTypes,
HasBuiltinAlias(HasBuiltinAlias), ManualCodegen(ManualCodegen.str()),
NF(NF) {
- // Init BuiltinName, Name and MangledName
+ // Init BuiltinName, Name and OverloadedName
BuiltinName = NewName.str();
Name = BuiltinName;
- if (NewMangledName.empty())
- MangledName = NewName.split("_").first.str();
+ if (NewOverloadedName.empty())
+ OverloadedName = NewName.split("_").first.str();
else
- MangledName = NewMangledName.str();
+ OverloadedName = NewOverloadedName.str();
if (!Suffix.empty())
Name += "_" + Suffix.str();
- if (!MangledSuffix.empty())
- MangledName += "_" + MangledSuffix.str();
+ if (!OverloadedSuffix.empty())
+ OverloadedName += "_" + OverloadedSuffix.str();
if (IsMasked) {
BuiltinName += "_m";
Name += "_m";