contrib/llvm-project/clang/include/clang/Basic/TargetBuiltins.h

   1 //===--- TargetBuiltins.h - Target specific builtin IDs ---------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 ///
   9 /// \file
  10 /// Enumerates target-specific builtins in their own namespaces within
  11 /// namespace ::clang.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_BASIC_TARGETBUILTINS_H
  16 #define LLVM_CLANG_BASIC_TARGETBUILTINS_H
  17
  18 #include <stdint.h>
  19 #include "clang/Basic/Builtins.h"
  20 #undef PPC
  21
  22 namespace clang {
  23
  24   namespace NEON {
  25   enum {
  26     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
  27 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
  28 #include "clang/Basic/BuiltinsNEON.def"
  29     FirstTSBuiltin
  30   };
  31   }
  32
  33   /// ARM builtins
  34   namespace ARM {
  35     enum {
  36       LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
  37       LastNEONBuiltin = NEON::FirstTSBuiltin - 1,
  38 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
  39 #include "clang/Basic/BuiltinsARM.def"
  40       LastTSBuiltin
  41     };
  42   }
  43
  44   /// AArch64 builtins
  45   namespace AArch64 {
  46   enum {
  47     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
  48     LastNEONBuiltin = NEON::FirstTSBuiltin - 1,
  49   #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
  50   #include "clang/Basic/BuiltinsAArch64.def"
  51     LastTSBuiltin
  52   };
  53   }
  54
  55   /// PPC builtins
  56   namespace PPC {
  57     enum {
  58         LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
  59 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
  60 #include "clang/Basic/BuiltinsPPC.def"
  61         LastTSBuiltin
  62     };
  63   }
  64
  65   /// NVPTX builtins
  66   namespace NVPTX {
  67     enum {
  68         LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
  69 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
  70 #include "clang/Basic/BuiltinsNVPTX.def"
  71         LastTSBuiltin
  72     };
  73   }
  74
  75   /// AMDGPU builtins
  76   namespace AMDGPU {
  77   enum {
  78     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
  79   #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
  80   #include "clang/Basic/BuiltinsAMDGPU.def"
  81     LastTSBuiltin
  82   };
  83   }
  84
  85   /// X86 builtins
  86   namespace X86 {
  87   enum {
  88     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
  89 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
  90 #include "clang/Basic/BuiltinsX86.def"
  91     FirstX86_64Builtin,
  92     LastX86CommonBuiltin = FirstX86_64Builtin - 1,
  93 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
  94 #include "clang/Basic/BuiltinsX86_64.def"
  95     LastTSBuiltin
  96   };
  97   }
  98
  99   /// Flags to identify the types for overloaded Neon builtins.
 100   ///
 101   /// These must be kept in sync with the flags in utils/TableGen/NeonEmitter.h.
 102   class NeonTypeFlags {
 103     enum {
 104       EltTypeMask = 0xf,
 105       UnsignedFlag = 0x10,
 106       QuadFlag = 0x20
 107     };
 108     uint32_t Flags;
 109
 110   public:
 111     enum EltType {
 112       Int8,
 113       Int16,
 114       Int32,
 115       Int64,
 116       Poly8,
 117       Poly16,
 118       Poly64,
 119       Poly128,
 120       Float16,
 121       Float32,
 122       Float64
 123     };
 124
 125     NeonTypeFlags(unsigned F) : Flags(F) {}
 126     NeonTypeFlags(EltType ET, bool IsUnsigned, bool IsQuad) : Flags(ET) {
 127       if (IsUnsigned)
 128         Flags |= UnsignedFlag;
 129       if (IsQuad)
 130         Flags |= QuadFlag;
 131     }
 132
 133     EltType getEltType() const { return (EltType)(Flags & EltTypeMask); }
 134     bool isPoly() const {
 135       EltType ET = getEltType();
 136       return ET == Poly8 || ET == Poly16;
 137     }
 138     bool isUnsigned() const { return (Flags & UnsignedFlag) != 0; }
 139     bool isQuad() const { return (Flags & QuadFlag) != 0; }
 140   };
 141
 142   /// Hexagon builtins
 143   namespace Hexagon {
 144     enum {
 145         LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
 146 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
 147 #include "clang/Basic/BuiltinsHexagon.def"
 148         LastTSBuiltin
 149     };
 150   }
 151
 152   /// MIPS builtins
 153   namespace Mips {
 154     enum {
 155         LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
 156 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
 157 #include "clang/Basic/BuiltinsMips.def"
 158         LastTSBuiltin
 159     };
 160   }
 161
 162   /// XCore builtins
 163   namespace XCore {
 164     enum {
 165         LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
 166 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
 167 #include "clang/Basic/BuiltinsXCore.def"
 168         LastTSBuiltin
 169     };
 170   }
 171
 172   /// Le64 builtins
 173   namespace Le64 {
 174   enum {
 175     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
 176   #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
 177   #include "clang/Basic/BuiltinsLe64.def"
 178     LastTSBuiltin
 179   };
 180   }
 181
 182   /// SystemZ builtins
 183   namespace SystemZ {
 184     enum {
 185         LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
 186 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
 187 #include "clang/Basic/BuiltinsSystemZ.def"
 188         LastTSBuiltin
 189     };
 190   }
 191
 192   /// WebAssembly builtins
 193   namespace WebAssembly {
 194     enum {
 195       LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
 196 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
 197 #include "clang/Basic/BuiltinsWebAssembly.def"
 198       LastTSBuiltin
 199     };
 200   }
 201
 202 } // end namespace clang.
 203
 204 #endif