llvm-project

1
//===--- Builtins.cpp - Builtin function implementation -------------------===//
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
//  This file implements various things for builtin functions.
10
//
11
//===----------------------------------------------------------------------===//
12

13
#include "clang/Basic/Builtins.h"
14
#include "BuiltinTargetFeatures.h"
15
#include "clang/Basic/IdentifierTable.h"
16
#include "clang/Basic/LangOptions.h"
17
#include "clang/Basic/TargetInfo.h"
18
#include "llvm/ADT/StringRef.h"
19
using namespace clang;
20

21
const char *HeaderDesc::getName() const {
22
  switch (ID) {
23
#define HEADER(ID, NAME)                                                       \
24
  case ID:                                                                     \
25
    return NAME;
26
#include "clang/Basic/BuiltinHeaders.def"
27
#undef HEADER
28
  };
29
  llvm_unreachable("Unknown HeaderDesc::HeaderID enum");
30
}
31

32
static constexpr Builtin::Info BuiltinInfo[] = {
33
    {"not a builtin function", nullptr, nullptr, nullptr, HeaderDesc::NO_HEADER,
34
     ALL_LANGUAGES},
35
#define BUILTIN(ID, TYPE, ATTRS)                                               \
36
  {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
37
#define LANGBUILTIN(ID, TYPE, ATTRS, LANGS)                                    \
38
  {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, LANGS},
39
#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER, LANGS)                             \
40
  {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, LANGS},
41
#include "clang/Basic/Builtins.inc"
42
};
43

44
const Builtin::Info &Builtin::Context::getRecord(unsigned ID) const {
45
  if (ID < Builtin::FirstTSBuiltin)
46
    return BuiltinInfo[ID];
47
  assert(((ID - Builtin::FirstTSBuiltin) <
48
          (TSRecords.size() + AuxTSRecords.size())) &&
49
         "Invalid builtin ID!");
50
  if (isAuxBuiltinID(ID))
51
    return AuxTSRecords[getAuxBuiltinID(ID) - Builtin::FirstTSBuiltin];
52
  return TSRecords[ID - Builtin::FirstTSBuiltin];
53
}
54

55
void Builtin::Context::InitializeTarget(const TargetInfo &Target,
56
                                        const TargetInfo *AuxTarget) {
57
  assert(TSRecords.empty() && "Already initialized target?");
58
  TSRecords = Target.getTargetBuiltins();
59
  if (AuxTarget)
60
    AuxTSRecords = AuxTarget->getTargetBuiltins();
61
}
62

63
bool Builtin::Context::isBuiltinFunc(llvm::StringRef FuncName) {
64
  bool InStdNamespace = FuncName.consume_front("std-");
65
  for (unsigned i = Builtin::NotBuiltin + 1; i != Builtin::FirstTSBuiltin;
66
       ++i) {
67
    if (FuncName == BuiltinInfo[i].Name &&
68
        (bool)strchr(BuiltinInfo[i].Attributes, 'z') == InStdNamespace)
69
      return strchr(BuiltinInfo[i].Attributes, 'f') != nullptr;
70
  }
71

72
  return false;
73
}
74

75
/// Is this builtin supported according to the given language options?
76
static bool builtinIsSupported(const Builtin::Info &BuiltinInfo,
77
                               const LangOptions &LangOpts) {
78
  /* Builtins Unsupported */
79
  if (LangOpts.NoBuiltin && strchr(BuiltinInfo.Attributes, 'f') != nullptr)
80
    return false;
81
  /* CorBuiltins Unsupported */
82
  if (!LangOpts.Coroutines && (BuiltinInfo.Langs & COR_LANG))
83
    return false;
84
  /* MathBuiltins Unsupported */
85
  if (LangOpts.NoMathBuiltin && BuiltinInfo.Header.ID == HeaderDesc::MATH_H)
86
    return false;
87
  /* GnuMode Unsupported */
88
  if (!LangOpts.GNUMode && (BuiltinInfo.Langs & GNU_LANG))
89
    return false;
90
  /* MSMode Unsupported */
91
  if (!LangOpts.MicrosoftExt && (BuiltinInfo.Langs & MS_LANG))
92
    return false;
93
  /* ObjC Unsupported */
94
  if (!LangOpts.ObjC && BuiltinInfo.Langs == OBJC_LANG)
95
    return false;
96
  /* OpenCLC Unsupported */
97
  if (!LangOpts.OpenCL && (BuiltinInfo.Langs & ALL_OCL_LANGUAGES))
98
    return false;
99
  /* OopenCL GAS Unsupported */
100
  if (!LangOpts.OpenCLGenericAddressSpace && (BuiltinInfo.Langs & OCL_GAS))
101
    return false;
102
  /* OpenCL Pipe Unsupported */
103
  if (!LangOpts.OpenCLPipes && (BuiltinInfo.Langs & OCL_PIPE))
104
    return false;
105

106
  // Device side enqueue is not supported until OpenCL 2.0. In 2.0 and higher
107
  // support is indicated with language option for blocks.
108

109
  /* OpenCL DSE Unsupported */
110
  if ((LangOpts.getOpenCLCompatibleVersion() < 200 || !LangOpts.Blocks) &&
111
      (BuiltinInfo.Langs & OCL_DSE))
112
    return false;
113
  /* OpenMP Unsupported */
114
  if (!LangOpts.OpenMP && BuiltinInfo.Langs == OMP_LANG)
115
    return false;
116
  /* CUDA Unsupported */
117
  if (!LangOpts.CUDA && BuiltinInfo.Langs == CUDA_LANG)
118
    return false;
119
  /* CPlusPlus Unsupported */
120
  if (!LangOpts.CPlusPlus && BuiltinInfo.Langs == CXX_LANG)
121
    return false;
122
  return true;
123
}
124

125
/// initializeBuiltins - Mark the identifiers for all the builtins with their
126
/// appropriate builtin ID # and mark any non-portable builtin identifiers as
127
/// such.
128
void Builtin::Context::initializeBuiltins(IdentifierTable &Table,
129
                                          const LangOptions& LangOpts) {
130
  // Step #1: mark all target-independent builtins with their ID's.
131
  for (unsigned i = Builtin::NotBuiltin+1; i != Builtin::FirstTSBuiltin; ++i)
132
    if (builtinIsSupported(BuiltinInfo[i], LangOpts)) {
133
      Table.get(BuiltinInfo[i].Name).setBuiltinID(i);
134
    }
135

136
  // Step #2: Register target-specific builtins.
137
  for (unsigned i = 0, e = TSRecords.size(); i != e; ++i)
138
    if (builtinIsSupported(TSRecords[i], LangOpts))
139
      Table.get(TSRecords[i].Name).setBuiltinID(i + Builtin::FirstTSBuiltin);
140

141
  // Step #3: Register target-specific builtins for AuxTarget.
142
  for (unsigned i = 0, e = AuxTSRecords.size(); i != e; ++i)
143
    Table.get(AuxTSRecords[i].Name)
144
        .setBuiltinID(i + Builtin::FirstTSBuiltin + TSRecords.size());
145

146
  // Step #4: Unregister any builtins specified by -fno-builtin-foo.
147
  for (llvm::StringRef Name : LangOpts.NoBuiltinFuncs) {
148
    bool InStdNamespace = Name.consume_front("std-");
149
    auto NameIt = Table.find(Name);
150
    if (NameIt != Table.end()) {
151
      unsigned ID = NameIt->second->getBuiltinID();
152
      if (ID != Builtin::NotBuiltin && isPredefinedLibFunction(ID) &&
153
          isInStdNamespace(ID) == InStdNamespace) {
154
        NameIt->second->clearBuiltinID();
155
      }
156
    }
157
  }
158
}
159

160
unsigned Builtin::Context::getRequiredVectorWidth(unsigned ID) const {
161
  const char *WidthPos = ::strchr(getRecord(ID).Attributes, 'V');
162
  if (!WidthPos)
163
    return 0;
164

165
  ++WidthPos;
166
  assert(*WidthPos == ':' &&
167
         "Vector width specifier must be followed by a ':'");
168
  ++WidthPos;
169

170
  char *EndPos;
171
  unsigned Width = ::strtol(WidthPos, &EndPos, 10);
172
  assert(*EndPos == ':' && "Vector width specific must end with a ':'");
173
  return Width;
174
}
175

176
bool Builtin::Context::isLike(unsigned ID, unsigned &FormatIdx,
177
                              bool &HasVAListArg, const char *Fmt) const {
178
  assert(Fmt && "Not passed a format string");
179
  assert(::strlen(Fmt) == 2 &&
180
         "Format string needs to be two characters long");
181
  assert(::toupper(Fmt[0]) == Fmt[1] &&
182
         "Format string is not in the form \"xX\"");
183

184
  const char *Like = ::strpbrk(getRecord(ID).Attributes, Fmt);
185
  if (!Like)
186
    return false;
187

188
  HasVAListArg = (*Like == Fmt[1]);
189

190
  ++Like;
191
  assert(*Like == ':' && "Format specifier must be followed by a ':'");
192
  ++Like;
193

194
  assert(::strchr(Like, ':') && "Format specifier must end with a ':'");
195
  FormatIdx = ::strtol(Like, nullptr, 10);
196
  return true;
197
}
198

199
bool Builtin::Context::isPrintfLike(unsigned ID, unsigned &FormatIdx,
200
                                    bool &HasVAListArg) {
201
  return isLike(ID, FormatIdx, HasVAListArg, "pP");
202
}
203

204
bool Builtin::Context::isScanfLike(unsigned ID, unsigned &FormatIdx,
205
                                   bool &HasVAListArg) {
206
  return isLike(ID, FormatIdx, HasVAListArg, "sS");
207
}
208

209
bool Builtin::Context::performsCallback(unsigned ID,
210
                                        SmallVectorImpl<int> &Encoding) const {
211
  const char *CalleePos = ::strchr(getRecord(ID).Attributes, 'C');
212
  if (!CalleePos)
213
    return false;
214

215
  ++CalleePos;
216
  assert(*CalleePos == '<' &&
217
         "Callback callee specifier must be followed by a '<'");
218
  ++CalleePos;
219

220
  char *EndPos;
221
  int CalleeIdx = ::strtol(CalleePos, &EndPos, 10);
222
  assert(CalleeIdx >= 0 && "Callee index is supposed to be positive!");
223
  Encoding.push_back(CalleeIdx);
224

225
  while (*EndPos == ',') {
226
    const char *PayloadPos = EndPos + 1;
227

228
    int PayloadIdx = ::strtol(PayloadPos, &EndPos, 10);
229
    Encoding.push_back(PayloadIdx);
230
  }
231

232
  assert(*EndPos == '>' && "Callback callee specifier must end with a '>'");
233
  return true;
234
}
235

236
bool Builtin::Context::canBeRedeclared(unsigned ID) const {
237
  return ID == Builtin::NotBuiltin || ID == Builtin::BI__va_start ||
238
         ID == Builtin::BI__builtin_assume_aligned ||
239
         (!hasReferenceArgsOrResult(ID) && !hasCustomTypechecking(ID)) ||
240
         isInStdNamespace(ID);
241
}
242

243
bool Builtin::evaluateRequiredTargetFeatures(
244
    StringRef RequiredFeatures, const llvm::StringMap<bool> &TargetFetureMap) {
245
  // Return true if the builtin doesn't have any required features.
246
  if (RequiredFeatures.empty())
247
    return true;
248
  assert(!RequiredFeatures.contains(' ') && "Space in feature list");
249

250
  TargetFeatures TF(TargetFetureMap);
251
  return TF.hasRequiredFeatures(RequiredFeatures);
252
}
253