caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dda73336ad22bd0b5ecda17040c50fb10fcbe5fb
clang-p2996/llvm/utils/TableGen/IntrinsicEmitter.cpp
Pierre van Houtryve fa3d789df1 [RFC][TableGen] Restructure TableGen Source (#80847) 
Refactor of the llvm-tblgen source into:
- a "Basic" library, which contains the bare minimum utilities to build
`llvm-min-tablegen`
- a "Common" library which contains all of the helpers for TableGen
backends. Such helpers can be shared by more than one backend, and even
unit tested (e.g. CodeExpander is, maybe we can add more over time)

Fixes #80647
2024-03-25 09:40:35 +01:00

725 lines
25 KiB
C++
Raw Blame History

//===- IntrinsicEmitter.cpp - Generate intrinsic information --------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This tablegen backend emits information about intrinsic functions.
//
//===----------------------------------------------------------------------===//
#include "Basic/CodeGenIntrinsics.h"
#include "Basic/SequenceToOffsetTable.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/ModRef.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/TableGen/Error.h"
#include "llvm/TableGen/Record.h"
#include "llvm/TableGen/StringToOffsetTable.h"
#include "llvm/TableGen/TableGenBackend.h"
#include <algorithm>
#include <array>
#include <cassert>
#include <map>
#include <optional>
#include <string>
#include <utility>
#include <vector>
using namespace llvm;
cl::OptionCategory GenIntrinsicCat("Options for -gen-intrinsic-enums");
cl::opt<std::string>
IntrinsicPrefix("intrinsic-prefix",
cl::desc("Generate intrinsics with this target prefix"),
cl::value_desc("target prefix"), cl::cat(GenIntrinsicCat));
namespace {
class IntrinsicEmitter {
RecordKeeper &Records;
public:
IntrinsicEmitter(RecordKeeper &R) : Records(R) {}
void run(raw_ostream &OS, bool Enums);
void EmitEnumInfo(const CodeGenIntrinsicTable &Ints, raw_ostream &OS);
void EmitArgKind(raw_ostream &OS);
void EmitIITInfo(raw_ostream &OS);
void EmitTargetInfo(const CodeGenIntrinsicTable &Ints, raw_ostream &OS);
void EmitIntrinsicToNameTable(const CodeGenIntrinsicTable &Ints,
raw_ostream &OS);
void EmitIntrinsicToOverloadTable(const CodeGenIntrinsicTable &Ints,
raw_ostream &OS);
void EmitGenerator(const CodeGenIntrinsicTable &Ints, raw_ostream &OS);
void EmitAttributes(const CodeGenIntrinsicTable &Ints, raw_ostream &OS);
void EmitIntrinsicToBuiltinMap(const CodeGenIntrinsicTable &Ints,
bool IsClang, raw_ostream &OS);
};
} // End anonymous namespace
//===----------------------------------------------------------------------===//
// IntrinsicEmitter Implementation
//===----------------------------------------------------------------------===//
void IntrinsicEmitter::run(raw_ostream &OS, bool Enums) {
emitSourceFileHeader("Intrinsic Function Source Fragment", OS);
CodeGenIntrinsicTable Ints(Records);
if (Enums) {
// Emit the enum information.
EmitEnumInfo(Ints, OS);
// Emit ArgKind for Intrinsics.h.
EmitArgKind(OS);
} else {
// Emit IIT_Info constants.
EmitIITInfo(OS);
// Emit the target metadata.
EmitTargetInfo(Ints, OS);
// Emit the intrinsic ID -> name table.
EmitIntrinsicToNameTable(Ints, OS);
// Emit the intrinsic ID -> overload table.
EmitIntrinsicToOverloadTable(Ints, OS);
// Emit the intrinsic declaration generator.
EmitGenerator(Ints, OS);
// Emit the intrinsic parameter attributes.
EmitAttributes(Ints, OS);
// Emit code to translate GCC builtins into LLVM intrinsics.
EmitIntrinsicToBuiltinMap(Ints, true, OS);
// Emit code to translate MS builtins into LLVM intrinsics.
EmitIntrinsicToBuiltinMap(Ints, false, OS);
}
}
void IntrinsicEmitter::EmitEnumInfo(const CodeGenIntrinsicTable &Ints,
raw_ostream &OS) {
// Find the TargetSet for which to generate enums. There will be an initial
// set with an empty target prefix which will include target independent
// intrinsics like dbg.value.
const CodeGenIntrinsicTable::TargetSet *Set = nullptr;
for (const auto &Target : Ints.Targets) {
if (Target.Name == IntrinsicPrefix) {
Set = &Target;
break;
}
}
if (!Set) {
std::vector<std::string> KnownTargets;
for (const auto &Target : Ints.Targets)
if (!Target.Name.empty())
KnownTargets.push_back(Target.Name);
PrintFatalError("tried to generate intrinsics for unknown target " +
IntrinsicPrefix +
"\nKnown targets are: " + join(KnownTargets, ", ") + "\n");
}
// Generate a complete header for target specific intrinsics.
if (IntrinsicPrefix.empty()) {
OS << "#ifdef GET_INTRINSIC_ENUM_VALUES\n";
} else {
std::string UpperPrefix = StringRef(IntrinsicPrefix).upper();
OS << "#ifndef LLVM_IR_INTRINSIC_" << UpperPrefix << "_ENUMS_H\n";
OS << "#define LLVM_IR_INTRINSIC_" << UpperPrefix << "_ENUMS_H\n\n";
OS << "namespace llvm {\n";
OS << "namespace Intrinsic {\n";
OS << "enum " << UpperPrefix << "Intrinsics : unsigned {\n";
}
OS << "// Enum values for intrinsics\n";
for (unsigned i = Set->Offset, e = Set->Offset + Set->Count; i != e; ++i) {
OS << " " << Ints[i].EnumName;
// Assign a value to the first intrinsic in this target set so that all
// intrinsic ids are distinct.
if (i == Set->Offset)
OS << " = " << (Set->Offset + 1);
OS << ", ";
if (Ints[i].EnumName.size() < 40)
OS.indent(40 - Ints[i].EnumName.size());
OS << " // " << Ints[i].Name << "\n";
}
// Emit num_intrinsics into the target neutral enum.
if (IntrinsicPrefix.empty()) {
OS << " num_intrinsics = " << (Ints.size() + 1) << "\n";
OS << "#endif\n\n";
} else {
OS << "}; // enum\n";
OS << "} // namespace Intrinsic\n";
OS << "} // namespace llvm\n\n";
OS << "#endif\n";
}
}
void IntrinsicEmitter::EmitArgKind(raw_ostream &OS) {
if (!IntrinsicPrefix.empty())
return;
OS << "// llvm::Intrinsic::IITDescriptor::ArgKind\n";
OS << "#ifdef GET_INTRINSIC_ARGKIND\n";
if (auto RecArgKind = Records.getDef("ArgKind")) {
for (auto &RV : RecArgKind->getValues())
OS << " AK_" << RV.getName() << " = " << *RV.getValue() << ",\n";
} else {
OS << "#error \"ArgKind is not defined\"\n";
}
OS << "#endif\n\n";
}
void IntrinsicEmitter::EmitIITInfo(raw_ostream &OS) {
OS << "#ifdef GET_INTRINSIC_IITINFO\n";
std::array<StringRef, 256> RecsByNumber;
auto IIT_Base = Records.getAllDerivedDefinitionsIfDefined("IIT_Base");
for (auto Rec : IIT_Base) {
auto Number = Rec->getValueAsInt("Number");
assert(0 <= Number && Number < (int)RecsByNumber.size() &&
"IIT_Info.Number should be uint8_t");
assert(RecsByNumber[Number].empty() && "Duplicate IIT_Info.Number");
RecsByNumber[Number] = Rec->getName();
}
if (IIT_Base.size() > 0) {
for (unsigned I = 0, E = RecsByNumber.size(); I < E; ++I)
if (!RecsByNumber[I].empty())
OS << " " << RecsByNumber[I] << " = " << I << ",\n";
} else {
OS << "#error \"class IIT_Base is not defined\"\n";
}
OS << "#endif\n\n";
}
void IntrinsicEmitter::EmitTargetInfo(const CodeGenIntrinsicTable &Ints,
raw_ostream &OS) {
OS << "// Target mapping\n";
OS << "#ifdef GET_INTRINSIC_TARGET_DATA\n";
OS << "struct IntrinsicTargetInfo {\n"
<< " llvm::StringLiteral Name;\n"
<< " size_t Offset;\n"
<< " size_t Count;\n"
<< "};\n";
OS << "static constexpr IntrinsicTargetInfo TargetInfos[] = {\n";
for (const auto &Target : Ints.Targets)
OS << " {llvm::StringLiteral(\"" << Target.Name << "\"), " << Target.Offset
<< ", " << Target.Count << "},\n";
OS << "};\n";
OS << "#endif\n\n";
}
void IntrinsicEmitter::EmitIntrinsicToNameTable(
const CodeGenIntrinsicTable &Ints, raw_ostream &OS) {
OS << "// Intrinsic ID to name table\n";
OS << "#ifdef GET_INTRINSIC_NAME_TABLE\n";
OS << " // Note that entry #0 is the invalid intrinsic!\n";
for (unsigned i = 0, e = Ints.size(); i != e; ++i)
OS << " \"" << Ints[i].Name << "\",\n";
OS << "#endif\n\n";
}
void IntrinsicEmitter::EmitIntrinsicToOverloadTable(
const CodeGenIntrinsicTable &Ints, raw_ostream &OS) {
OS << "// Intrinsic ID to overload bitset\n";
OS << "#ifdef GET_INTRINSIC_OVERLOAD_TABLE\n";
OS << "static const uint8_t OTable[] = {\n";
OS << " 0";
for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
// Add one to the index so we emit a null bit for the invalid #0 intrinsic.
if ((i + 1) % 8 == 0)
OS << ",\n 0";
if (Ints[i].isOverloaded)
OS << " | (1<<" << (i + 1) % 8 << ')';
}
OS << "\n};\n\n";
// OTable contains a true bit at the position if the intrinsic is overloaded.
OS << "return (OTable[id/8] & (1 << (id%8))) != 0;\n";
OS << "#endif\n\n";
}
/// ComputeFixedEncoding - If we can encode the type signature for this
/// intrinsic into 32 bits, return it. If not, return ~0U.
static void ComputeFixedEncoding(const CodeGenIntrinsic &Int,
std::vector<unsigned char> &TypeSig) {
if (auto *R = Int.TheDef->getValue("TypeSig")) {
for (auto &a : cast<ListInit>(R->getValue())->getValues()) {
for (auto &b : cast<ListInit>(a)->getValues())
TypeSig.push_back(cast<IntInit>(b)->getValue());
}
}
}
static void printIITEntry(raw_ostream &OS, unsigned char X) {
OS << (unsigned)X;
}
void IntrinsicEmitter::EmitGenerator(const CodeGenIntrinsicTable &Ints,
raw_ostream &OS) {
// If we can compute a 32-bit fixed encoding for this intrinsic, do so and
// capture it in this vector, otherwise store a ~0U.
std::vector<unsigned> FixedEncodings;
SequenceToOffsetTable<std::vector<unsigned char>> LongEncodingTable;
std::vector<unsigned char> TypeSig;
// Compute the unique argument type info.
for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
// Get the signature for the intrinsic.
TypeSig.clear();
ComputeFixedEncoding(Ints[i], TypeSig);
// Check to see if we can encode it into a 32-bit word. We can only encode
// 8 nibbles into a 32-bit word.
if (TypeSig.size() <= 8) {
bool Failed = false;
unsigned Result = 0;
for (unsigned i = 0, e = TypeSig.size(); i != e; ++i) {
// If we had an unencodable argument, bail out.
if (TypeSig[i] > 15) {
Failed = true;
break;
}
Result = (Result << 4) | TypeSig[e - i - 1];
}
// If this could be encoded into a 31-bit word, return it.
if (!Failed && (Result >> 31) == 0) {
FixedEncodings.push_back(Result);
continue;
}
}
// Otherwise, we're going to unique the sequence into the
// LongEncodingTable, and use its offset in the 32-bit table instead.
LongEncodingTable.add(TypeSig);
// This is a placehold that we'll replace after the table is laid out.
FixedEncodings.push_back(~0U);
}
LongEncodingTable.layout();
OS << "// Global intrinsic function declaration type table.\n";
OS << "#ifdef GET_INTRINSIC_GENERATOR_GLOBAL\n";
OS << "static const unsigned IIT_Table[] = {\n ";
for (unsigned i = 0, e = FixedEncodings.size(); i != e; ++i) {
if ((i & 7) == 7)
OS << "\n ";
// If the entry fit in the table, just emit it.
if (FixedEncodings[i] != ~0U) {
OS << "0x" << Twine::utohexstr(FixedEncodings[i]) << ", ";
continue;
}
TypeSig.clear();
ComputeFixedEncoding(Ints[i], TypeSig);
// Otherwise, emit the offset into the long encoding table. We emit it this
// way so that it is easier to read the offset in the .def file.
OS << "(1U<<31) | " << LongEncodingTable.get(TypeSig) << ", ";
}
OS << "0\n};\n\n";
// Emit the shared table of register lists.
OS << "static const unsigned char IIT_LongEncodingTable[] = {\n";
if (!LongEncodingTable.empty())
LongEncodingTable.emit(OS, printIITEntry);
OS << " 255\n};\n\n";
OS << "#endif\n\n"; // End of GET_INTRINSIC_GENERATOR_GLOBAL
}
namespace {
std::optional<bool> compareFnAttributes(const CodeGenIntrinsic *L,
const CodeGenIntrinsic *R) {
// Sort throwing intrinsics after non-throwing intrinsics.
if (L->canThrow != R->canThrow)
return R->canThrow;
if (L->isNoDuplicate != R->isNoDuplicate)
return R->isNoDuplicate;
if (L->isNoMerge != R->isNoMerge)
return R->isNoMerge;
if (L->isNoReturn != R->isNoReturn)
return R->isNoReturn;
if (L->isNoCallback != R->isNoCallback)
return R->isNoCallback;
if (L->isNoSync != R->isNoSync)
return R->isNoSync;
if (L->isNoFree != R->isNoFree)
return R->isNoFree;
if (L->isWillReturn != R->isWillReturn)
return R->isWillReturn;
if (L->isCold != R->isCold)
return R->isCold;
if (L->isConvergent != R->isConvergent)
return R->isConvergent;
if (L->isSpeculatable != R->isSpeculatable)
return R->isSpeculatable;
if (L->hasSideEffects != R->hasSideEffects)
return R->hasSideEffects;
if (L->isStrictFP != R->isStrictFP)
return R->isStrictFP;
// Try to order by readonly/readnone attribute.
uint32_t LK = L->ME.toIntValue();
uint32_t RK = R->ME.toIntValue();
if (LK != RK)
return (LK > RK);
return std::nullopt;
}
struct FnAttributeComparator {
bool operator()(const CodeGenIntrinsic *L, const CodeGenIntrinsic *R) const {
return compareFnAttributes(L, R).value_or(false);
}
};
struct AttributeComparator {
bool operator()(const CodeGenIntrinsic *L, const CodeGenIntrinsic *R) const {
if (std::optional<bool> Res = compareFnAttributes(L, R))
return *Res;
// Order by argument attributes.
// This is reliable because each side is already sorted internally.
return (L->ArgumentAttributes < R->ArgumentAttributes);
}
};
} // End anonymous namespace
/// EmitAttributes - This emits the Intrinsic::getAttributes method.
void IntrinsicEmitter::EmitAttributes(const CodeGenIntrinsicTable &Ints,
raw_ostream &OS) {
OS << "// Add parameter attributes that are not common to all intrinsics.\n";
OS << "#ifdef GET_INTRINSIC_ATTRIBUTES\n";
// Compute unique argument attribute sets.
std::map<SmallVector<CodeGenIntrinsic::ArgAttribute, 0>, unsigned>
UniqArgAttributes;
OS << "static AttributeSet getIntrinsicArgAttributeSet("
<< "LLVMContext &C, unsigned ID) {\n"
<< " switch (ID) {\n"
<< " default: llvm_unreachable(\"Invalid attribute set number\");\n";
for (const CodeGenIntrinsic &Int : Ints) {
for (auto &Attrs : Int.ArgumentAttributes) {
if (Attrs.empty())
continue;
unsigned ID = UniqArgAttributes.size();
if (!UniqArgAttributes.try_emplace(Attrs, ID).second)
continue;
assert(is_sorted(Attrs) && "Argument attributes are not sorted");
OS << " case " << ID << ":\n";
OS << " return AttributeSet::get(C, {\n";
for (const CodeGenIntrinsic::ArgAttribute &Attr : Attrs) {
switch (Attr.Kind) {
case CodeGenIntrinsic::NoCapture:
OS << " Attribute::get(C, Attribute::NoCapture),\n";
break;
case CodeGenIntrinsic::NoAlias:
OS << " Attribute::get(C, Attribute::NoAlias),\n";
break;
case CodeGenIntrinsic::NoUndef:
OS << " Attribute::get(C, Attribute::NoUndef),\n";
break;
case CodeGenIntrinsic::NonNull:
OS << " Attribute::get(C, Attribute::NonNull),\n";
break;
case CodeGenIntrinsic::Returned:
OS << " Attribute::get(C, Attribute::Returned),\n";
break;
case CodeGenIntrinsic::ReadOnly:
OS << " Attribute::get(C, Attribute::ReadOnly),\n";
break;
case CodeGenIntrinsic::WriteOnly:
OS << " Attribute::get(C, Attribute::WriteOnly),\n";
break;
case CodeGenIntrinsic::ReadNone:
OS << " Attribute::get(C, Attribute::ReadNone),\n";
break;
case CodeGenIntrinsic::ImmArg:
OS << " Attribute::get(C, Attribute::ImmArg),\n";
break;
case CodeGenIntrinsic::Alignment:
OS << " Attribute::get(C, Attribute::Alignment, " << Attr.Value
<< "),\n";
break;
case CodeGenIntrinsic::Dereferenceable:
OS << " Attribute::get(C, Attribute::Dereferenceable, "
<< Attr.Value << "),\n";
break;
}
}
OS << " });\n";
}
}
OS << " }\n";
OS << "}\n\n";
// Compute unique function attribute sets.
std::map<const CodeGenIntrinsic *, unsigned, FnAttributeComparator>
UniqFnAttributes;
OS << "static AttributeSet getIntrinsicFnAttributeSet("
<< "LLVMContext &C, unsigned ID) {\n"
<< " switch (ID) {\n"
<< " default: llvm_unreachable(\"Invalid attribute set number\");\n";
for (const CodeGenIntrinsic &Intrinsic : Ints) {
unsigned ID = UniqFnAttributes.size();
if (!UniqFnAttributes.try_emplace(&Intrinsic, ID).second)
continue;
OS << " case " << ID << ":\n"
<< " return AttributeSet::get(C, {\n";
if (!Intrinsic.canThrow)
OS << " Attribute::get(C, Attribute::NoUnwind),\n";
if (Intrinsic.isNoReturn)
OS << " Attribute::get(C, Attribute::NoReturn),\n";
if (Intrinsic.isNoCallback)
OS << " Attribute::get(C, Attribute::NoCallback),\n";
if (Intrinsic.isNoSync)
OS << " Attribute::get(C, Attribute::NoSync),\n";
if (Intrinsic.isNoFree)
OS << " Attribute::get(C, Attribute::NoFree),\n";
if (Intrinsic.isWillReturn)
OS << " Attribute::get(C, Attribute::WillReturn),\n";
if (Intrinsic.isCold)
OS << " Attribute::get(C, Attribute::Cold),\n";
if (Intrinsic.isNoDuplicate)
OS << " Attribute::get(C, Attribute::NoDuplicate),\n";
if (Intrinsic.isNoMerge)
OS << " Attribute::get(C, Attribute::NoMerge),\n";
if (Intrinsic.isConvergent)
OS << " Attribute::get(C, Attribute::Convergent),\n";
if (Intrinsic.isSpeculatable)
OS << " Attribute::get(C, Attribute::Speculatable),\n";
if (Intrinsic.isStrictFP)
OS << " Attribute::get(C, Attribute::StrictFP),\n";
MemoryEffects ME = Intrinsic.ME;
// TODO: IntrHasSideEffects should affect not only readnone intrinsics.
if (ME.doesNotAccessMemory() && Intrinsic.hasSideEffects)
ME = MemoryEffects::unknown();
if (ME != MemoryEffects::unknown()) {
OS << " Attribute::getWithMemoryEffects(C, "
<< "MemoryEffects::createFromIntValue(" << ME.toIntValue() << ")),\n";
}
OS << " });\n";
}
OS << " }\n";
OS << "}\n\n";
OS << "AttributeList Intrinsic::getAttributes(LLVMContext &C, ID id) {\n";
// Compute the maximum number of attribute arguments and the map
typedef std::map<const CodeGenIntrinsic *, unsigned, AttributeComparator>
UniqAttrMapTy;
UniqAttrMapTy UniqAttributes;
unsigned maxArgAttrs = 0;
unsigned AttrNum = 0;
for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
const CodeGenIntrinsic &intrinsic = Ints[i];
maxArgAttrs =
std::max(maxArgAttrs, unsigned(intrinsic.ArgumentAttributes.size()));
unsigned &N = UniqAttributes[&intrinsic];
if (N)
continue;
N = ++AttrNum;
assert(N < 65536 && "Too many unique attributes for table!");
}
// Emit an array of AttributeList. Most intrinsics will have at least one
// entry, for the function itself (index ~1), which is usually nounwind.
OS << " static const uint16_t IntrinsicsToAttributesMap[] = {\n";
for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
const CodeGenIntrinsic &intrinsic = Ints[i];
OS << " " << UniqAttributes[&intrinsic] << ", // " << intrinsic.Name
<< "\n";
}
OS << " };\n\n";
OS << " std::pair<unsigned, AttributeSet> AS[" << maxArgAttrs + 1 << "];\n";
OS << " unsigned NumAttrs = 0;\n";
OS << " if (id != 0) {\n";
OS << " switch(IntrinsicsToAttributesMap[id - 1]) {\n";
OS << " default: llvm_unreachable(\"Invalid attribute number\");\n";
for (auto UniqAttribute : UniqAttributes) {
OS << " case " << UniqAttribute.second << ": {\n";
const CodeGenIntrinsic &Intrinsic = *(UniqAttribute.first);
// Keep track of the number of attributes we're writing out.
unsigned numAttrs = 0;
for (const auto &[AttrIdx, Attrs] :
enumerate(Intrinsic.ArgumentAttributes)) {
if (Attrs.empty())
continue;
unsigned ID = UniqArgAttributes.find(Attrs)->second;
OS << " AS[" << numAttrs++ << "] = {" << AttrIdx
<< ", getIntrinsicArgAttributeSet(C, " << ID << ")};\n";
}
if (!Intrinsic.canThrow ||
(Intrinsic.ME != MemoryEffects::unknown() &&
!Intrinsic.hasSideEffects) ||
Intrinsic.isNoReturn || Intrinsic.isNoCallback || Intrinsic.isNoSync ||
Intrinsic.isNoFree || Intrinsic.isWillReturn || Intrinsic.isCold ||
Intrinsic.isNoDuplicate || Intrinsic.isNoMerge ||
Intrinsic.isConvergent || Intrinsic.isSpeculatable ||
Intrinsic.isStrictFP) {
unsigned ID = UniqFnAttributes.find(&Intrinsic)->second;
OS << " AS[" << numAttrs++ << "] = {AttributeList::FunctionIndex, "
<< "getIntrinsicFnAttributeSet(C, " << ID << ")};\n";
}
if (numAttrs) {
OS << " NumAttrs = " << numAttrs << ";\n";
OS << " break;\n";
OS << " }\n";
} else {
OS << " return AttributeList();\n";
OS << " }\n";
}
}
OS << " }\n";
OS << " }\n";
OS << " return AttributeList::get(C, ArrayRef(AS, NumAttrs));\n";
OS << "}\n";
OS << "#endif // GET_INTRINSIC_ATTRIBUTES\n\n";
}
void IntrinsicEmitter::EmitIntrinsicToBuiltinMap(
const CodeGenIntrinsicTable &Ints, bool IsClang, raw_ostream &OS) {
StringRef CompilerName = (IsClang ? "Clang" : "MS");
StringRef UpperCompilerName = (IsClang ? "CLANG" : "MS");
typedef std::map<std::string, std::map<std::string, std::string>> BIMTy;
BIMTy BuiltinMap;
StringToOffsetTable Table;
for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
const std::string &BuiltinName =
IsClang ? Ints[i].ClangBuiltinName : Ints[i].MSBuiltinName;
if (!BuiltinName.empty()) {
// Get the map for this target prefix.
std::map<std::string, std::string> &BIM =
BuiltinMap[Ints[i].TargetPrefix];
if (!BIM.insert(std::pair(BuiltinName, Ints[i].EnumName)).second)
PrintFatalError(Ints[i].TheDef->getLoc(),
"Intrinsic '" + Ints[i].TheDef->getName() +
"': duplicate " + CompilerName + " builtin name!");
Table.GetOrAddStringOffset(BuiltinName);
}
}
OS << "// Get the LLVM intrinsic that corresponds to a builtin.\n";
OS << "// This is used by the C front-end. The builtin name is passed\n";
OS << "// in as BuiltinName, and a target prefix (e.g. 'ppc') is passed\n";
OS << "// in as TargetPrefix. The result is assigned to 'IntrinsicID'.\n";
OS << "#ifdef GET_LLVM_INTRINSIC_FOR_" << UpperCompilerName << "_BUILTIN\n";
OS << "Intrinsic::ID Intrinsic::getIntrinsicFor" << CompilerName
<< "Builtin(const char "
<< "*TargetPrefixStr, StringRef BuiltinNameStr) {\n";
if (Table.Empty()) {
OS << " return Intrinsic::not_intrinsic;\n";
OS << "}\n";
OS << "#endif\n\n";
return;
}
OS << " static const char BuiltinNames[] = {\n";
Table.EmitCharArray(OS);
OS << " };\n\n";
OS << " struct BuiltinEntry {\n";
OS << " Intrinsic::ID IntrinID;\n";
OS << " unsigned StrTabOffset;\n";
OS << " const char *getName() const {\n";
OS << " return &BuiltinNames[StrTabOffset];\n";
OS << " }\n";
OS << " bool operator<(StringRef RHS) const {\n";
OS << " return strncmp(getName(), RHS.data(), RHS.size()) < 0;\n";
OS << " }\n";
OS << " };\n";
OS << " StringRef TargetPrefix(TargetPrefixStr);\n\n";
// Note: this could emit significantly better code if we cared.
for (auto &I : BuiltinMap) {
OS << " ";
if (!I.first.empty())
OS << "if (TargetPrefix == \"" << I.first << "\") ";
else
OS << "/* Target Independent Builtins */ ";
OS << "{\n";
// Emit the comparisons for this target prefix.
OS << " static const BuiltinEntry " << I.first << "Names[] = {\n";
for (const auto &P : I.second) {
OS << " {Intrinsic::" << P.second << ", "
<< Table.GetOrAddStringOffset(P.first) << "}, // " << P.first << "\n";
}
OS << " };\n";
OS << " auto I = std::lower_bound(std::begin(" << I.first << "Names),\n";
OS << " std::end(" << I.first << "Names),\n";
OS << " BuiltinNameStr);\n";
OS << " if (I != std::end(" << I.first << "Names) &&\n";
OS << " I->getName() == BuiltinNameStr)\n";
OS << " return I->IntrinID;\n";
OS << " }\n";
}
OS << " return ";
OS << "Intrinsic::not_intrinsic;\n";
OS << "}\n";
OS << "#endif\n\n";
}
static void EmitIntrinsicEnums(RecordKeeper &RK, raw_ostream &OS) {
IntrinsicEmitter(RK).run(OS, /*Enums=*/true);
}
static TableGen::Emitter::Opt X("gen-intrinsic-enums", EmitIntrinsicEnums,
"Generate intrinsic enums");
static void EmitIntrinsicImpl(RecordKeeper &RK, raw_ostream &OS) {
IntrinsicEmitter(RK).run(OS, /*Enums=*/false);
}
static TableGen::Emitter::Opt Y("gen-intrinsic-impl", EmitIntrinsicImpl,
"Generate intrinsic information");
Reference in New Issue View Git Blame Copy Permalink