1 //===--- Builtins.cpp - Builtin function implementation -------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements various things for builtin functions.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Basic/Builtins.h"
15 #include "clang/Basic/IdentifierTable.h"
16 #include "clang/Basic/TargetInfo.h"
17 #include "clang/Basic/LangOptions.h"
18 using namespace clang
;
20 static const Builtin::Info BuiltinInfo
[] = {
21 { "not a builtin function", 0, 0, 0, ALL_LANGUAGES
, false },
22 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES, false },
23 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER, BUILTIN_LANG) { #ID, TYPE, ATTRS, HEADER,\
24 BUILTIN_LANG, false },
25 #include "clang/Basic/Builtins.def"
28 const Builtin::Info
&Builtin::Context::GetRecord(unsigned ID
) const {
29 if (ID
< Builtin::FirstTSBuiltin
)
30 return BuiltinInfo
[ID
];
31 assert(ID
- Builtin::FirstTSBuiltin
< NumTSRecords
&& "Invalid builtin ID!");
32 return TSRecords
[ID
- Builtin::FirstTSBuiltin
];
35 Builtin::Context::Context(const TargetInfo
&Target
) {
36 // Get the target specific builtins from the target.
39 Target
.getTargetBuiltins(TSRecords
, NumTSRecords
);
42 /// InitializeBuiltins - Mark the identifiers for all the builtins with their
43 /// appropriate builtin ID # and mark any non-portable builtin identifiers as
45 void Builtin::Context::InitializeBuiltins(IdentifierTable
&Table
,
46 const LangOptions
& LangOpts
) {
47 // Step #1: mark all target-independent builtins with their ID's.
48 for (unsigned i
= Builtin::NotBuiltin
+1; i
!= Builtin::FirstTSBuiltin
; ++i
)
49 if (!BuiltinInfo
[i
].Suppressed
&&
50 (!LangOpts
.NoBuiltin
|| !strchr(BuiltinInfo
[i
].Attributes
, 'f'))) {
52 BuiltinInfo
[i
].builtin_lang
!= clang::OBJC_LANG
)
53 Table
.get(BuiltinInfo
[i
].Name
).setBuiltinID(i
);
56 // Step #2: Register target-specific builtins.
57 for (unsigned i
= 0, e
= NumTSRecords
; i
!= e
; ++i
)
58 if (!TSRecords
[i
].Suppressed
&&
59 (!LangOpts
.NoBuiltin
||
60 (TSRecords
[i
].Attributes
&&
61 !strchr(TSRecords
[i
].Attributes
, 'f'))))
62 Table
.get(TSRecords
[i
].Name
).setBuiltinID(i
+Builtin::FirstTSBuiltin
);
66 Builtin::Context::GetBuiltinNames(llvm::SmallVectorImpl
<const char *> &Names
,
68 // Final all target-independent names
69 for (unsigned i
= Builtin::NotBuiltin
+1; i
!= Builtin::FirstTSBuiltin
; ++i
)
70 if (!BuiltinInfo
[i
].Suppressed
&&
71 (!NoBuiltins
|| !strchr(BuiltinInfo
[i
].Attributes
, 'f')))
72 Names
.push_back(BuiltinInfo
[i
].Name
);
74 // Find target-specific names.
75 for (unsigned i
= 0, e
= NumTSRecords
; i
!= e
; ++i
)
76 if (!TSRecords
[i
].Suppressed
&&
78 (TSRecords
[i
].Attributes
&&
79 !strchr(TSRecords
[i
].Attributes
, 'f'))))
80 Names
.push_back(TSRecords
[i
].Name
);
83 void Builtin::Context::ForgetBuiltin(unsigned ID
, IdentifierTable
&Table
) {
84 Table
.get(GetRecord(ID
).Name
).setBuiltinID(0);
88 Builtin::Context::isPrintfLike(unsigned ID
, unsigned &FormatIdx
,
90 const char *Printf
= strpbrk(GetRecord(ID
).Attributes
, "pP");
94 HasVAListArg
= (*Printf
== 'P');
97 assert(*Printf
== ':' && "p or P specifier must have be followed by a ':'");
100 assert(strchr(Printf
, ':') && "printf specifier must end with a ':'");
101 FormatIdx
= strtol(Printf
, 0, 10);
105 // FIXME: Refactor with isPrintfLike.
107 Builtin::Context::isScanfLike(unsigned ID
, unsigned &FormatIdx
,
108 bool &HasVAListArg
) {
109 const char *Scanf
= strpbrk(GetRecord(ID
).Attributes
, "sS");
113 HasVAListArg
= (*Scanf
== 'S');
116 assert(*Scanf
== ':' && "s or S specifier must have be followed by a ':'");
119 assert(strchr(Scanf
, ':') && "printf specifier must end with a ':'");
120 FormatIdx
= strtol(Scanf
, 0, 10);