TargetBuiltins.h Source File (original) (raw)

15#ifndef LLVM_CLANG_BASIC_TARGETBUILTINS_H

16#define LLVM_CLANG_BASIC_TARGETBUILTINS_H

18#include

21#include "llvm/Support/MathExtras.h"

22#undef PPC

26 namespace NEON {

27 enum {

29#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

30#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BI##ID,

31#include "clang/Basic/BuiltinsNEON.def"

34 }

37 namespace ARM {

38 enum {

41#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

42#include "clang/Basic/BuiltinsARM.def"

45 }

47 namespace SVE {

48 enum {

50#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

51#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BI##ID,

52#include "clang/Basic/BuiltinsSVE.def"

54 };

55 }

57 namespace SME {

58 enum {

60#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

61#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BI##ID,

62#include "clang/Basic/BuiltinsSME.def"

64 };

65 }

68 namespace AArch64 {

69 enum {

76 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,

77 #include "clang/Basic/BuiltinsAArch64.def"

80 }

83 namespace BPF {

84 enum {

86 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,

87 #include "clang/Basic/BuiltinsBPF.inc"

90 }

93 namespace PPC {

94 enum {

96#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

97#include "clang/Basic/BuiltinsPPC.def"

100 }

101

102

103 namespace NVPTX {

104 enum {

106#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

107#include "clang/Basic/BuiltinsNVPTX.def"

110 }

111

112

113 namespace AMDGPU {

114 enum {

116 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,

117 #include "clang/Basic/BuiltinsAMDGPU.def"

120 }

121

122

123 namespace SPIRV {

124 enum {

126#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

127#include "clang/Basic/BuiltinsSPIRV.inc"

130 }

131

132

133 namespace X86 {

134 enum {

136#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

137#include "clang/Basic/BuiltinsX86.inc"

140#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

141#include "clang/Basic/BuiltinsX86_64.inc"

144 }

145

146

147 namespace VE {

148 enum {

150#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

151#include "clang/Basic/BuiltinsVE.def"

154 }

155

156 namespace RISCVVector {

157 enum {

159#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

160#include "clang/Basic/BuiltinsRISCVVector.def"

162 };

163 }

164

165

166 namespace RISCV {

167 enum {

171#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

172#include "clang/Basic/BuiltinsRISCV.inc"

175 }

176

177

178 namespace LoongArch {

179 enum {

181#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

182#include "clang/Basic/BuiltinsLoongArch.def"

185 }

186

187

188

189

191 enum {

192 EltTypeMask = 0xf,

193 UnsignedFlag = 0x10,

194 QuadFlag = 0x20

195 };

196 uint32_t Flags;

197

198 public:

213

216 if (IsUnsigned)

217 Flags |= UnsignedFlag;

218 if (IsQuad)

219 Flags |= QuadFlag;

220 }

221

226 }

227 bool isUnsigned() const { return (Flags & UnsignedFlag) != 0; }

228 bool isQuad() const { return (Flags & QuadFlag) != 0; }

233 return 8;

238 return 16;

241 return 32;

245 return 64;

247 return 128;

248 }

249 llvm_unreachable("Invalid NeonTypeFlag!");

250 }

251 };

252

253

255#define LLVM_GET_ARM_INTRIN_IMMCHECKTYPES

256#include "clang/Basic/arm_immcheck_types.inc"

257#undef LLVM_GET_ARM_INTRIN_IMMCHECKTYPES

258 };

259

260

262 uint64_t Flags;

263 unsigned EltTypeShift;

264 unsigned MemEltTypeShift;

265 unsigned MergeTypeShift;

266 unsigned SplatOperandMaskShift;

267

268 public:

269#define LLVM_GET_SVE_TYPEFLAGS

270#include "clang/Basic/arm_sve_typeflags.inc"

271#undef LLVM_GET_SVE_TYPEFLAGS

272

274#define LLVM_GET_SVE_ELTTYPES

275#include "clang/Basic/arm_sve_typeflags.inc"

276#undef LLVM_GET_SVE_ELTTYPES

277 };

278

280#define LLVM_GET_SVE_MEMELTTYPES

281#include "clang/Basic/arm_sve_typeflags.inc"

282#undef LLVM_GET_SVE_MEMELTTYPES

283 };

284

286#define LLVM_GET_SVE_MERGETYPES

287#include "clang/Basic/arm_sve_typeflags.inc"

288#undef LLVM_GET_SVE_MERGETYPES

289 };

290

292 EltTypeShift = llvm::countr_zero(EltTypeMask);

293 MemEltTypeShift = llvm::countr_zero(MemEltTypeMask);

294 MergeTypeShift = llvm::countr_zero(MergeTypeMask);

295 SplatOperandMaskShift = llvm::countr_zero(SplatOperandMask);

296 }

297

299 return (EltType)((Flags & EltTypeMask) >> EltTypeShift);

300 }

301

303 return (MemEltType)((Flags & MemEltTypeMask) >> MemEltTypeShift);

304 }

305

307 return (MergeType)((Flags & MergeTypeMask) >> MergeTypeShift);

308 }

309

311 return ((Flags & SplatOperandMask) >> SplatOperandMaskShift) - 1;

312 }

313

315 return Flags & SplatOperandMask;

316 }

317

318 bool isLoad() const { return Flags & IsLoad; }

319 bool isStore() const { return Flags & IsStore; }

320 bool isGatherLoad() const { return Flags & IsGatherLoad; }

322 bool isStructLoad() const { return Flags & IsStructLoad; }

324 bool isZExtReturn() const { return Flags & IsZExtReturn; }

328 return Flags & IsOverloadWhileOrMultiVecCvt;

329 }

333 bool isPrefetch() const { return Flags & IsPrefetch; }

341 bool isUndef() const { return Flags & IsUndef; }

343 bool isTupleGet() const { return Flags & IsTupleGet; }

344 bool isTupleSet() const { return Flags & IsTupleSet; }

345 bool isReadZA() const { return Flags & IsReadZA; }

346 bool isWriteZA() const { return Flags & IsWriteZA; }

347 bool setsFPMR() const { return Flags & SetsFPMR; }

349 uint64_t getBits() const { return Flags; }

350 bool isFlagSet(uint64_t Flag) const { return Flags & Flag; }

351 };

352

353

354 namespace Hexagon {

355 enum {

357#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

358#include "clang/Basic/BuiltinsHexagon.def"

361 }

362

363

364 namespace Mips {

365 enum {

367#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

368#include "clang/Basic/BuiltinsMips.def"

371 }

372

373

374 namespace XCore {

375 enum {

377#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

378#include "clang/Basic/BuiltinsXCore.def"

381 }

382

383

384 namespace SystemZ {

385 enum {

387#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

388#include "clang/Basic/BuiltinsSystemZ.def"

391 }

392

393

394 namespace WebAssembly {

395 enum {

397#define BUILTIN(ID, TYPE, ATTRS) BI##ID,

398#include "clang/Basic/BuiltinsWebAssembly.def"

401 }

402

409

410}

411

412#endif

Defines enum values for all the target-independent builtin functions.

Flags to identify the types for overloaded Neon builtins.

NeonTypeFlags(unsigned F)

unsigned getEltSizeInBits() const

EltType getEltType() const

NeonTypeFlags(EltType ET, bool IsUnsigned, bool IsQuad)

Flags to identify the types for overloaded SVE builtins.

bool isZExtReturn() const

bool isReverseUSDOT() const

bool isOverloadNone() const

MemEltType getMemEltType() const

bool isGatherLoad() const

bool isOverloadCvt() const

EltType getEltType() const

bool isOverloadDefault() const

bool isOverloadWhileRW() const

bool isReverseMergeAnyAccOp() const

bool isReductionQV() const

bool isFlagSet(uint64_t Flag) const

bool isInsertOp1SVALL() const

bool isAppendSVALL() const

bool isReverseMergeAnyBinOp() const

bool isStructStore() const

bool isTupleCreate() const

bool isGatherPrefetch() const

bool hasSplatOperand() const

MergeType getMergeType() const

bool isByteIndexed() const

bool isStructLoad() const

bool isOverloadWhileOrMultiVecCvt() const

unsigned getSplatOperand() const

bool isScatterStore() const

bool isReverseCompare() const

The JSON file list parser is used to communicate input to InstallAPI.

static constexpr uint64_t LargestBuiltinID