1 //===- IntrinsicEmitter.cpp - Generate intrinsic information --------------===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by Chris Lattner and is distributed under
6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This tablegen backend emits information about intrinsic functions.
12 //===----------------------------------------------------------------------===//
14 #include "CodeGenTarget.h"
15 #include "IntrinsicEmitter.h"
17 #include "llvm/ADT/StringExtras.h"
21 //===----------------------------------------------------------------------===//
22 // IntrinsicEmitter Implementation
23 //===----------------------------------------------------------------------===//
25 void IntrinsicEmitter::run(std::ostream &OS) {
26 EmitSourceFileHeader("Intrinsic Function Source Fragment", OS);
28 std::vector<CodeGenIntrinsic> Ints = LoadIntrinsics(Records);
30 // Emit the enum information.
31 EmitEnumInfo(Ints, OS);
33 // Emit the intrinsic ID -> name table.
34 EmitIntrinsicToNameTable(Ints, OS);
36 // Emit the function name recognizer.
37 EmitFnNameRecognizer(Ints, OS);
39 // Emit the intrinsic verifier.
40 EmitVerifier(Ints, OS);
42 // Emit the intrinsic declaration generator.
43 EmitGenerator(Ints, OS);
45 // Emit mod/ref info for each function.
46 EmitModRefInfo(Ints, OS);
48 // Emit table of non-memory accessing intrinsics.
49 EmitNoMemoryInfo(Ints, OS);
51 // Emit side effect info for each intrinsic.
52 EmitSideEffectInfo(Ints, OS);
54 // Emit a list of intrinsics with corresponding GCC builtins.
55 EmitGCCBuiltinList(Ints, OS);
57 // Emit code to translate GCC builtins into LLVM intrinsics.
58 EmitIntrinsicToGCCBuiltinMap(Ints, OS);
61 void IntrinsicEmitter::EmitEnumInfo(const std::vector<CodeGenIntrinsic> &Ints,
63 OS << "// Enum values for Intrinsics.h\n";
64 OS << "#ifdef GET_INTRINSIC_ENUM_VALUES\n";
65 for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
66 OS << " " << Ints[i].EnumName;
67 OS << ((i != e-1) ? ", " : " ");
68 OS << std::string(40-Ints[i].EnumName.size(), ' ')
69 << "// " << Ints[i].Name << "\n";
74 void IntrinsicEmitter::
75 EmitFnNameRecognizer(const std::vector<CodeGenIntrinsic> &Ints,
77 // Build a function name -> intrinsic name mapping.
78 std::map<std::string, unsigned> IntMapping;
79 for (unsigned i = 0, e = Ints.size(); i != e; ++i)
80 IntMapping[Ints[i].Name] = i;
82 OS << "// Function name -> enum value recognizer code.\n";
83 OS << "#ifdef GET_FUNCTION_RECOGNIZER\n";
84 OS << " switch (Name[5]) {\n";
86 // Emit the intrinsics in sorted order.
88 for (std::map<std::string, unsigned>::iterator I = IntMapping.begin(),
89 E = IntMapping.end(); I != E; ++I) {
90 if (I->first[5] != LastChar) {
91 LastChar = I->first[5];
93 OS << " case '" << LastChar << "':\n";
96 // For overloaded intrinsics, only the prefix needs to match
97 if (Ints[I->second].isOverloaded)
98 OS << " if (Len > " << I->first.size()
99 << " && !memcmp(Name, \"" << I->first << ".\", "
100 << (I->first.size() + 1) << ")) return Intrinsic::"
101 << Ints[I->second].EnumName << ";\n";
103 OS << " if (Len == " << I->first.size()
104 << " && !memcmp(Name, \"" << I->first << "\", "
105 << I->first.size() << ")) return Intrinsic::"
106 << Ints[I->second].EnumName << ";\n";
112 void IntrinsicEmitter::
113 EmitIntrinsicToNameTable(const std::vector<CodeGenIntrinsic> &Ints,
115 OS << "// Intrinsic ID to name table\n";
116 OS << "#ifdef GET_INTRINSIC_NAME_TABLE\n";
117 OS << " // Note that entry #0 is the invalid intrinsic!\n";
118 for (unsigned i = 0, e = Ints.size(); i != e; ++i)
119 OS << " \"" << Ints[i].Name << "\",\n";
123 static void EmitTypeForValueType(std::ostream &OS, MVT::ValueType VT) {
124 if (MVT::isInteger(VT)) {
125 unsigned BitWidth = MVT::getSizeInBits(VT);
126 OS << "IntegerType::get(" << BitWidth << ")";
127 } else if (VT == MVT::Other) {
128 // MVT::OtherVT is used to mean the empty struct type here.
129 OS << "StructType::get(std::vector<const Type *>())";
130 } else if (VT == MVT::f32) {
131 OS << "Type::FloatTy";
132 } else if (VT == MVT::f64) {
133 OS << "Type::DoubleTy";
134 } else if (VT == MVT::f80) {
135 OS << "Type::X86_FP80Ty";
136 } else if (VT == MVT::f128) {
137 OS << "Type::FP128Ty";
138 } else if (VT == MVT::ppcf128) {
139 OS << "Type::PPC_FP128Ty";
140 } else if (VT == MVT::isVoid) {
141 OS << "Type::VoidTy";
143 assert(false && "Unsupported ValueType!");
147 static void EmitTypeGenerate(std::ostream &OS, Record *ArgType,
149 MVT::ValueType VT = getValueType(ArgType->getValueAsDef("VT"));
151 if (ArgType->isSubClassOf("LLVMMatchType")) {
152 unsigned Number = ArgType->getValueAsInt("Number");
153 assert(Number < ArgNo && "Invalid matching number!");
154 OS << "Tys[" << Number << "]";
155 } else if (VT == MVT::iAny || VT == MVT::fAny) {
156 // NOTE: The ArgNo variable here is not the absolute argument number, it is
157 // the index of the "arbitrary" type in the Tys array passed to the
158 // Intrinsic::getDeclaration function. Consequently, we only want to
159 // increment it when we actually hit an overloaded type. Getting this wrong
160 // leads to very subtle bugs!
161 OS << "Tys[" << ArgNo++ << "]";
162 } else if (MVT::isVector(VT)) {
163 OS << "VectorType::get(";
164 EmitTypeForValueType(OS, MVT::getVectorElementType(VT));
165 OS << ", " << MVT::getVectorNumElements(VT) << ")";
166 } else if (VT == MVT::iPTR) {
167 OS << "PointerType::get(";
168 EmitTypeGenerate(OS, ArgType->getValueAsDef("ElTy"), ArgNo);
170 } else if (VT == MVT::isVoid) {
172 OS << "Type::VoidTy";
174 // MVT::isVoid is used to mean varargs here.
177 EmitTypeForValueType(OS, VT);
181 /// RecordListComparator - Provide a determinstic comparator for lists of
184 struct RecordListComparator {
185 bool operator()(const std::vector<Record*> &LHS,
186 const std::vector<Record*> &RHS) const {
189 if (i == RHS.size()) return false; // RHS is shorter than LHS.
190 if (LHS[i] != RHS[i])
191 return LHS[i]->getName() < RHS[i]->getName();
192 } while (++i != LHS.size());
194 return i != RHS.size();
199 void IntrinsicEmitter::EmitVerifier(const std::vector<CodeGenIntrinsic> &Ints,
201 OS << "// Verifier::visitIntrinsicFunctionCall code.\n";
202 OS << "#ifdef GET_INTRINSIC_VERIFIER\n";
203 OS << " switch (ID) {\n";
204 OS << " default: assert(0 && \"Invalid intrinsic!\");\n";
206 // This checking can emit a lot of very common code. To reduce the amount of
207 // code that we emit, batch up cases that have identical types. This avoids
208 // problems where GCC can run out of memory compiling Verifier.cpp.
209 typedef std::map<std::vector<Record*>, std::vector<unsigned>,
210 RecordListComparator> MapTy;
211 MapTy UniqueArgInfos;
213 // Compute the unique argument type info.
214 for (unsigned i = 0, e = Ints.size(); i != e; ++i)
215 UniqueArgInfos[Ints[i].ArgTypeDefs].push_back(i);
217 // Loop through the array, emitting one comparison for each batch.
218 for (MapTy::iterator I = UniqueArgInfos.begin(),
219 E = UniqueArgInfos.end(); I != E; ++I) {
220 for (unsigned i = 0, e = I->second.size(); i != e; ++i) {
221 OS << " case Intrinsic::" << Ints[I->second[i]].EnumName << ":\t\t// "
222 << Ints[I->second[i]].Name << "\n";
225 const std::vector<Record*> &ArgTypes = I->first;
226 OS << " VerifyIntrinsicPrototype(ID, IF, " << ArgTypes.size() << ", ";
227 for (unsigned j = 0; j != ArgTypes.size(); ++j) {
228 Record *ArgType = ArgTypes[j];
229 if (ArgType->isSubClassOf("LLVMMatchType")) {
230 unsigned Number = ArgType->getValueAsInt("Number");
231 assert(Number < j && "Invalid matching number!");
234 MVT::ValueType VT = getValueType(ArgType->getValueAsDef("VT"));
235 OS << getEnumName(VT);
236 if (VT == MVT::isVoid && j != 0 && j != ArgTypes.size()-1)
237 throw "Var arg type not last argument";
239 if (j != ArgTypes.size()-1)
250 void IntrinsicEmitter::EmitGenerator(const std::vector<CodeGenIntrinsic> &Ints,
252 OS << "// Code for generating Intrinsic function declarations.\n";
253 OS << "#ifdef GET_INTRINSIC_GENERATOR\n";
254 OS << " switch (id) {\n";
255 OS << " default: assert(0 && \"Invalid intrinsic!\");\n";
257 // Similar to GET_INTRINSIC_VERIFIER, batch up cases that have identical
259 typedef std::map<std::vector<Record*>, std::vector<unsigned>,
260 RecordListComparator> MapTy;
261 MapTy UniqueArgInfos;
263 // Compute the unique argument type info.
264 for (unsigned i = 0, e = Ints.size(); i != e; ++i)
265 UniqueArgInfos[Ints[i].ArgTypeDefs].push_back(i);
267 // Loop through the array, emitting one generator for each batch.
268 for (MapTy::iterator I = UniqueArgInfos.begin(),
269 E = UniqueArgInfos.end(); I != E; ++I) {
270 for (unsigned i = 0, e = I->second.size(); i != e; ++i) {
271 OS << " case Intrinsic::" << Ints[I->second[i]].EnumName << ":\t\t// "
272 << Ints[I->second[i]].Name << "\n";
275 const std::vector<Record*> &ArgTypes = I->first;
276 unsigned N = ArgTypes.size();
279 getValueType(ArgTypes[N-1]->getValueAsDef("VT")) == MVT::isVoid) {
280 OS << " IsVarArg = true;\n";
285 OS << " ResultTy = ";
286 EmitTypeGenerate(OS, ArgTypes[0], ArgNo);
289 for (unsigned j = 1; j != N; ++j) {
290 OS << " ArgTys.push_back(";
291 EmitTypeGenerate(OS, ArgTypes[j], ArgNo);
300 void IntrinsicEmitter::EmitModRefInfo(const std::vector<CodeGenIntrinsic> &Ints,
302 OS << "// BasicAliasAnalysis code.\n";
303 OS << "#ifdef GET_MODREF_BEHAVIOR\n";
304 for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
305 switch (Ints[i].ModRef) {
307 case CodeGenIntrinsic::NoMem:
308 OS << " NoMemoryIntrinsics->set(Intrinsic::" << Ints[i].EnumName << ");\n";
310 case CodeGenIntrinsic::ReadArgMem:
311 case CodeGenIntrinsic::ReadMem:
312 OS << " OnlyReadsMemoryIntrinsics->set(Intrinsic::" << Ints[i].EnumName << ");\n";
319 void IntrinsicEmitter::
320 EmitNoMemoryInfo(const std::vector<CodeGenIntrinsic> &Ints, std::ostream &OS) {
321 OS << "// SelectionDAGIsel code.\n";
322 OS << "#ifdef GET_NO_MEMORY_INTRINSICS\n";
323 OS << " switch (IntrinsicID) {\n";
324 OS << " default: break;\n";
325 for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
326 switch (Ints[i].ModRef) {
328 case CodeGenIntrinsic::NoMem:
329 OS << " case Intrinsic::" << Ints[i].EnumName << ":\n";
333 OS << " return true; // These intrinsics do not reference memory.\n";
338 void IntrinsicEmitter::
339 EmitSideEffectInfo(const std::vector<CodeGenIntrinsic> &Ints, std::ostream &OS){
340 OS << "// Return true if doesn't access or only reads memory.\n";
341 OS << "#ifdef GET_SIDE_EFFECT_INFO\n";
342 OS << " switch (IntrinsicID) {\n";
343 OS << " default: break;\n";
344 for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
345 switch (Ints[i].ModRef) {
347 case CodeGenIntrinsic::NoMem:
348 case CodeGenIntrinsic::ReadArgMem:
349 case CodeGenIntrinsic::ReadMem:
350 OS << " case Intrinsic::" << Ints[i].EnumName << ":\n";
354 OS << " return true; // These intrinsics have no side effects.\n";
359 void IntrinsicEmitter::
360 EmitGCCBuiltinList(const std::vector<CodeGenIntrinsic> &Ints, std::ostream &OS){
361 OS << "// Get the GCC builtin that corresponds to an LLVM intrinsic.\n";
362 OS << "#ifdef GET_GCC_BUILTIN_NAME\n";
363 OS << " switch (F->getIntrinsicID()) {\n";
364 OS << " default: BuiltinName = \"\"; break;\n";
365 for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
366 if (!Ints[i].GCCBuiltinName.empty()) {
367 OS << " case Intrinsic::" << Ints[i].EnumName << ": BuiltinName = \""
368 << Ints[i].GCCBuiltinName << "\"; break;\n";
375 void IntrinsicEmitter::
376 EmitIntrinsicToGCCBuiltinMap(const std::vector<CodeGenIntrinsic> &Ints,
378 typedef std::map<std::pair<std::string, std::string>, std::string> BIMTy;
380 for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
381 if (!Ints[i].GCCBuiltinName.empty()) {
382 std::pair<std::string, std::string> Key(Ints[i].GCCBuiltinName,
383 Ints[i].TargetPrefix);
384 if (!BuiltinMap.insert(std::make_pair(Key, Ints[i].EnumName)).second)
385 throw "Intrinsic '" + Ints[i].TheDef->getName() +
386 "': duplicate GCC builtin name!";
390 OS << "// Get the LLVM intrinsic that corresponds to a GCC builtin.\n";
391 OS << "// This is used by the C front-end. The GCC builtin name is passed\n";
392 OS << "// in as BuiltinName, and a target prefix (e.g. 'ppc') is passed\n";
393 OS << "// in as TargetPrefix. The result is assigned to 'IntrinsicID'.\n";
394 OS << "#ifdef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN\n";
396 // Note: this could emit significantly better code if we cared.
397 for (BIMTy::iterator I = BuiltinMap.begin(), E = BuiltinMap.end();I != E;++I){
399 if (!I->first.second.empty()) {
400 // Emit this as a strcmp, so it can be constant folded by the FE.
401 OS << "!strcmp(TargetPrefix, \"" << I->first.second << "\") &&\n"
404 OS << "!strcmp(BuiltinName, \"" << I->first.first << "\"))\n";
405 OS << " IntrinsicID = Intrinsic::" << I->second << ";\n";
408 OS << " IntrinsicID = Intrinsic::not_intrinsic;\n";