contrib/llvm/tools/clang/include/clang/Basic/Builtins.h

   1 //===--- Builtins.h - Builtin function header -------------------*- 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 /// Defines enum values for all the target-independent builtin
  11 /// functions.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_BASIC_BUILTINS_H
  16 #define LLVM_CLANG_BASIC_BUILTINS_H
  17
  18 #include "llvm/ADT/ArrayRef.h"
  19 #include <cstring>
  20
  21 // VC++ defines 'alloca' as an object-like macro, which interferes with our
  22 // builtins.
  23 #undef alloca
  24
  25 namespace clang {
  26 class TargetInfo;
  27 class IdentifierTable;
  28 class ASTContext;
  29 class QualType;
  30 class LangOptions;
  31
  32 enum LanguageID {
  33   GNU_LANG = 0x1,     // builtin requires GNU mode.
  34   C_LANG = 0x2,       // builtin for c only.
  35   CXX_LANG = 0x4,     // builtin for cplusplus only.
  36   OBJC_LANG = 0x8,    // builtin for objective-c and objective-c++
  37   MS_LANG = 0x10,     // builtin requires MS mode.
  38   OCLC20_LANG = 0x20, // builtin for OpenCL C 2.0 only.
  39   OCLC1X_LANG = 0x40, // builtin for OpenCL C 1.x only.
  40   OMP_LANG = 0x80,    // builtin requires OpenMP.
  41   ALL_LANGUAGES = C_LANG | CXX_LANG | OBJC_LANG, // builtin for all languages.
  42   ALL_GNU_LANGUAGES = ALL_LANGUAGES | GNU_LANG,  // builtin requires GNU mode.
  43   ALL_MS_LANGUAGES = ALL_LANGUAGES | MS_LANG,    // builtin requires MS mode.
  44   ALL_OCLC_LANGUAGES = OCLC1X_LANG | OCLC20_LANG // builtin for OCLC languages.
  45 };
  46
  47 namespace Builtin {
  48 enum ID {
  49   NotBuiltin  = 0,      // This is not a builtin function.
  50 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
  51 #include "clang/Basic/Builtins.def"
  52   FirstTSBuiltin
  53 };
  54
  55 struct Info {
  56   const char *Name, *Type, *Attributes, *HeaderName;
  57   LanguageID Langs;
  58   const char *Features;
  59 };
  60
  61 /// Holds information about both target-independent and
  62 /// target-specific builtins, allowing easy queries by clients.
  63 ///
  64 /// Builtins from an optional auxiliary target are stored in
  65 /// AuxTSRecords. Their IDs are shifted up by TSRecords.size() and need to
  66 /// be translated back with getAuxBuiltinID() before use.
  67 class Context {
  68   llvm::ArrayRef<Info> TSRecords;
  69   llvm::ArrayRef<Info> AuxTSRecords;
  70
  71 public:
  72   Context() {}
  73
  74   /// Perform target-specific initialization
  75   /// \param AuxTarget Target info to incorporate builtins from. May be nullptr.
  76   void InitializeTarget(const TargetInfo &Target, const TargetInfo *AuxTarget);
  77
  78   /// Mark the identifiers for all the builtins with their
  79   /// appropriate builtin ID # and mark any non-portable builtin identifiers as
  80   /// such.
  81   void initializeBuiltins(IdentifierTable &Table, const LangOptions& LangOpts);
  82
  83   /// Return the identifier name for the specified builtin,
  84   /// e.g. "__builtin_abs".
  85   const char *getName(unsigned ID) const {
  86     return getRecord(ID).Name;
  87   }
  88
  89   /// Get the type descriptor string for the specified builtin.
  90   const char *getTypeString(unsigned ID) const {
  91     return getRecord(ID).Type;
  92   }
  93
  94   /// Return true if this function is a target-specific builtin.
  95   bool isTSBuiltin(unsigned ID) const {
  96     return ID >= Builtin::FirstTSBuiltin;
  97   }
  98
  99   /// Return true if this function has no side effects.
 100   bool isPure(unsigned ID) const {
 101     return strchr(getRecord(ID).Attributes, 'U') != nullptr;
 102   }
 103
 104   /// Return true if this function has no side effects and doesn't
 105   /// read memory.
 106   bool isConst(unsigned ID) const {
 107     return strchr(getRecord(ID).Attributes, 'c') != nullptr;
 108   }
 109
 110   /// Return true if we know this builtin never throws an exception.
 111   bool isNoThrow(unsigned ID) const {
 112     return strchr(getRecord(ID).Attributes, 'n') != nullptr;
 113   }
 114
 115   /// Return true if we know this builtin never returns.
 116   bool isNoReturn(unsigned ID) const {
 117     return strchr(getRecord(ID).Attributes, 'r') != nullptr;
 118   }
 119
 120   /// Return true if we know this builtin can return twice.
 121   bool isReturnsTwice(unsigned ID) const {
 122     return strchr(getRecord(ID).Attributes, 'j') != nullptr;
 123   }
 124
 125   /// Returns true if this builtin does not perform the side-effects
 126   /// of its arguments.
 127   bool isUnevaluated(unsigned ID) const {
 128     return strchr(getRecord(ID).Attributes, 'u') != nullptr;
 129   }
 130
 131   /// Return true if this is a builtin for a libc/libm function,
 132   /// with a "__builtin_" prefix (e.g. __builtin_abs).
 133   bool isLibFunction(unsigned ID) const {
 134     return strchr(getRecord(ID).Attributes, 'F') != nullptr;
 135   }
 136
 137   /// Determines whether this builtin is a predefined libc/libm
 138   /// function, such as "malloc", where we know the signature a
 139   /// priori.
 140   bool isPredefinedLibFunction(unsigned ID) const {
 141     return strchr(getRecord(ID).Attributes, 'f') != nullptr;
 142   }
 143
 144   /// Returns true if this builtin requires appropriate header in other
 145   /// compilers. In Clang it will work even without including it, but we can emit
 146   /// a warning about missing header.
 147   bool isHeaderDependentFunction(unsigned ID) const {
 148     return strchr(getRecord(ID).Attributes, 'h') != nullptr;
 149   }
 150
 151   /// Determines whether this builtin is a predefined compiler-rt/libgcc
 152   /// function, such as "__clear_cache", where we know the signature a
 153   /// priori.
 154   bool isPredefinedRuntimeFunction(unsigned ID) const {
 155     return strchr(getRecord(ID).Attributes, 'i') != nullptr;
 156   }
 157
 158   /// Determines whether this builtin has custom typechecking.
 159   bool hasCustomTypechecking(unsigned ID) const {
 160     return strchr(getRecord(ID).Attributes, 't') != nullptr;
 161   }
 162
 163   /// Determines whether this builtin has a result or any arguments which
 164   /// are pointer types.
 165   bool hasPtrArgsOrResult(unsigned ID) const {
 166     return strchr(getRecord(ID).Type, '*') != nullptr;
 167   }
 168
 169   /// Return true if this builtin has a result or any arguments which are
 170   /// reference types.
 171   bool hasReferenceArgsOrResult(unsigned ID) const {
 172     return strchr(getRecord(ID).Type, '&') != nullptr ||
 173            strchr(getRecord(ID).Type, 'A') != nullptr;
 174   }
 175
 176   /// Completely forget that the given ID was ever considered a builtin,
 177   /// e.g., because the user provided a conflicting signature.
 178   void forgetBuiltin(unsigned ID, IdentifierTable &Table);
 179
 180   /// If this is a library function that comes from a specific
 181   /// header, retrieve that header name.
 182   const char *getHeaderName(unsigned ID) const {
 183     return getRecord(ID).HeaderName;
 184   }
 185
 186   /// Determine whether this builtin is like printf in its
 187   /// formatting rules and, if so, set the index to the format string
 188   /// argument and whether this function as a va_list argument.
 189   bool isPrintfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg);
 190
 191   /// Determine whether this builtin is like scanf in its
 192   /// formatting rules and, if so, set the index to the format string
 193   /// argument and whether this function as a va_list argument.
 194   bool isScanfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg);
 195
 196   /// Determine whether this builtin has callback behavior (see
 197   /// llvm::AbstractCallSites for details). If so, add the index to the
 198   /// callback callee argument and the callback payload arguments.
 199   bool performsCallback(unsigned ID,
 200                         llvm::SmallVectorImpl<int> &Encoding) const;
 201
 202   /// Return true if this function has no side effects and doesn't
 203   /// read memory, except for possibly errno.
 204   ///
 205   /// Such functions can be const when the MathErrno lang option is disabled.
 206   bool isConstWithoutErrno(unsigned ID) const {
 207     return strchr(getRecord(ID).Attributes, 'e') != nullptr;
 208   }
 209
 210   const char *getRequiredFeatures(unsigned ID) const {
 211     return getRecord(ID).Features;
 212   }
 213
 214   unsigned getRequiredVectorWidth(unsigned ID) const;
 215
 216   /// Return true if builtin ID belongs to AuxTarget.
 217   bool isAuxBuiltinID(unsigned ID) const {
 218     return ID >= (Builtin::FirstTSBuiltin + TSRecords.size());
 219   }
 220
 221   /// Return real builtin ID (i.e. ID it would have during compilation
 222   /// for AuxTarget).
 223   unsigned getAuxBuiltinID(unsigned ID) const { return ID - TSRecords.size(); }
 224
 225   /// Returns true if this is a libc/libm function without the '__builtin_'
 226   /// prefix.
 227   static bool isBuiltinFunc(const char *Name);
 228
 229   /// Returns true if this is a builtin that can be redeclared.  Returns true
 230   /// for non-builtins.
 231   bool canBeRedeclared(unsigned ID) const;
 232
 233 private:
 234   const Info &getRecord(unsigned ID) const;
 235
 236   /// Is this builtin supported according to the given language options?
 237   bool builtinIsSupported(const Builtin::Info &BuiltinInfo,
 238                           const LangOptions &LangOpts);
 239
 240   /// Helper function for isPrintfLike and isScanfLike.
 241   bool isLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg,
 242               const char *Fmt) const;
 243 };
 244
 245 }
 246
 247 /// Kinds of BuiltinTemplateDecl.
 248 enum BuiltinTemplateKind : int {
 249   /// This names the __make_integer_seq BuiltinTemplateDecl.
 250   BTK__make_integer_seq,
 251
 252   /// This names the __type_pack_element BuiltinTemplateDecl.
 253   BTK__type_pack_element
 254 };
 255
 256 } // end namespace clang
 257 #endif