forked from OSchip/llvm-project
461 lines
14 KiB
C++
461 lines
14 KiB
C++
//===-- KindMapping.cpp ---------------------------------------------------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "flang/Optimizer/Support/KindMapping.h"
|
|
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
|
|
#include "llvm/Support/CommandLine.h"
|
|
|
|
/// Allow the user to set the FIR intrinsic type kind value to LLVM type
|
|
/// mappings. Note that these are not mappings from kind values to any
|
|
/// other MLIR dialect, only to LLVM IR. The default values follow the f18
|
|
/// front-end kind mappings.
|
|
|
|
using Bitsize = fir::KindMapping::Bitsize;
|
|
using KindTy = fir::KindMapping::KindTy;
|
|
using LLVMTypeID = fir::KindMapping::LLVMTypeID;
|
|
using MatchResult = fir::KindMapping::MatchResult;
|
|
|
|
static llvm::cl::opt<std::string>
|
|
clKindMapping("kind-mapping",
|
|
llvm::cl::desc("kind mapping string to set kind precision"),
|
|
llvm::cl::value_desc("kind-mapping-string"),
|
|
llvm::cl::init(fir::KindMapping::getDefaultMap()));
|
|
|
|
static llvm::cl::opt<std::string>
|
|
clDefaultKinds("default-kinds",
|
|
llvm::cl::desc("string to set default kind values"),
|
|
llvm::cl::value_desc("default-kind-string"),
|
|
llvm::cl::init(fir::KindMapping::getDefaultKinds()));
|
|
|
|
// Keywords for the floating point types.
|
|
|
|
static constexpr const char *kwHalf = "Half";
|
|
static constexpr const char *kwBFloat = "BFloat";
|
|
static constexpr const char *kwFloat = "Float";
|
|
static constexpr const char *kwDouble = "Double";
|
|
static constexpr const char *kwX86FP80 = "X86_FP80";
|
|
static constexpr const char *kwFP128 = "FP128";
|
|
static constexpr const char *kwPPCFP128 = "PPC_FP128";
|
|
|
|
/// Integral types default to the kind value being the size of the value in
|
|
/// bytes. The default is to scale from bytes to bits.
|
|
static Bitsize defaultScalingKind(KindTy kind) {
|
|
const unsigned BITS_IN_BYTE = 8;
|
|
return kind * BITS_IN_BYTE;
|
|
}
|
|
|
|
/// Floating-point types default to the kind value being the size of the value
|
|
/// in bytes. The default is to translate kinds of 2, 3, 4, 8, 10, and 16 to a
|
|
/// valid llvm::Type::TypeID value. Otherwise, the default is FloatTyID.
|
|
static LLVMTypeID defaultRealKind(KindTy kind) {
|
|
switch (kind) {
|
|
case 2:
|
|
return LLVMTypeID::HalfTyID;
|
|
case 3:
|
|
return LLVMTypeID::BFloatTyID;
|
|
case 4:
|
|
return LLVMTypeID::FloatTyID;
|
|
case 8:
|
|
return LLVMTypeID::DoubleTyID;
|
|
case 10:
|
|
return LLVMTypeID::X86_FP80TyID;
|
|
case 16:
|
|
return LLVMTypeID::FP128TyID;
|
|
default:
|
|
return LLVMTypeID::FloatTyID;
|
|
}
|
|
}
|
|
|
|
// lookup the kind-value given the defaults, the mappings, and a KIND key
|
|
template <typename RT, char KEY>
|
|
static RT doLookup(std::function<RT(KindTy)> def,
|
|
const llvm::DenseMap<std::pair<char, KindTy>, RT> &map,
|
|
KindTy kind) {
|
|
std::pair<char, KindTy> key{KEY, kind};
|
|
auto iter = map.find(key);
|
|
if (iter != map.end())
|
|
return iter->second;
|
|
return def(kind);
|
|
}
|
|
|
|
// do a lookup for INTERGER, LOGICAL, or CHARACTER
|
|
template <char KEY, typename MAP>
|
|
static Bitsize getIntegerLikeBitsize(KindTy kind, const MAP &map) {
|
|
return doLookup<Bitsize, KEY>(defaultScalingKind, map, kind);
|
|
}
|
|
|
|
// do a lookup for REAL or COMPLEX
|
|
template <char KEY, typename MAP>
|
|
static LLVMTypeID getFloatLikeTypeID(KindTy kind, const MAP &map) {
|
|
return doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind);
|
|
}
|
|
|
|
template <char KEY, typename MAP>
|
|
static const llvm::fltSemantics &getFloatSemanticsOfKind(KindTy kind,
|
|
const MAP &map) {
|
|
switch (doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind)) {
|
|
case LLVMTypeID::HalfTyID:
|
|
return llvm::APFloat::IEEEhalf();
|
|
case LLVMTypeID::BFloatTyID:
|
|
return llvm::APFloat::BFloat();
|
|
case LLVMTypeID::FloatTyID:
|
|
return llvm::APFloat::IEEEsingle();
|
|
case LLVMTypeID::DoubleTyID:
|
|
return llvm::APFloat::IEEEdouble();
|
|
case LLVMTypeID::X86_FP80TyID:
|
|
return llvm::APFloat::x87DoubleExtended();
|
|
case LLVMTypeID::FP128TyID:
|
|
return llvm::APFloat::IEEEquad();
|
|
case LLVMTypeID::PPC_FP128TyID:
|
|
return llvm::APFloat::PPCDoubleDouble();
|
|
default:
|
|
llvm_unreachable("Invalid floating type");
|
|
}
|
|
}
|
|
|
|
/// Parse an intrinsic type code. The codes are ('a', CHARACTER), ('c',
|
|
/// COMPLEX), ('i', INTEGER), ('l', LOGICAL), and ('r', REAL).
|
|
static MatchResult parseCode(char &code, const char *&ptr, const char *endPtr) {
|
|
if (ptr >= endPtr)
|
|
return mlir::failure();
|
|
if (*ptr != 'a' && *ptr != 'c' && *ptr != 'i' && *ptr != 'l' && *ptr != 'r')
|
|
return mlir::failure();
|
|
code = *ptr++;
|
|
return mlir::success();
|
|
}
|
|
|
|
/// Same as `parseCode` but adds the ('d', DOUBLE PRECISION) code.
|
|
static MatchResult parseDefCode(char &code, const char *&ptr,
|
|
const char *endPtr) {
|
|
if (ptr >= endPtr)
|
|
return mlir::failure();
|
|
if (*ptr == 'd') {
|
|
code = *ptr++;
|
|
return mlir::success();
|
|
}
|
|
return parseCode(code, ptr, endPtr);
|
|
}
|
|
|
|
template <char ch>
|
|
static MatchResult parseSingleChar(const char *&ptr, const char *endPtr) {
|
|
if (ptr >= endPtr || *ptr != ch)
|
|
return mlir::failure();
|
|
++ptr;
|
|
return mlir::success();
|
|
}
|
|
|
|
static MatchResult parseColon(const char *&ptr, const char *endPtr) {
|
|
return parseSingleChar<':'>(ptr, endPtr);
|
|
}
|
|
|
|
static MatchResult parseComma(const char *&ptr, const char *endPtr) {
|
|
return parseSingleChar<','>(ptr, endPtr);
|
|
}
|
|
|
|
/// Recognize and parse an unsigned integer.
|
|
static MatchResult parseInt(unsigned &result, const char *&ptr,
|
|
const char *endPtr) {
|
|
const char *beg = ptr;
|
|
while (ptr < endPtr && *ptr >= '0' && *ptr <= '9')
|
|
ptr++;
|
|
if (beg == ptr)
|
|
return mlir::failure();
|
|
llvm::StringRef ref(beg, ptr - beg);
|
|
int temp;
|
|
if (ref.consumeInteger(10, temp))
|
|
return mlir::failure();
|
|
result = temp;
|
|
return mlir::success();
|
|
}
|
|
|
|
static mlir::LogicalResult matchString(const char *&ptr, const char *endPtr,
|
|
llvm::StringRef literal) {
|
|
llvm::StringRef s(ptr, endPtr - ptr);
|
|
if (s.startswith(literal)) {
|
|
ptr += literal.size();
|
|
return mlir::success();
|
|
}
|
|
return mlir::failure();
|
|
}
|
|
|
|
/// Recognize and parse the various floating-point keywords. These follow the
|
|
/// LLVM naming convention.
|
|
static MatchResult parseTypeID(LLVMTypeID &result, const char *&ptr,
|
|
const char *endPtr) {
|
|
if (mlir::succeeded(matchString(ptr, endPtr, kwHalf))) {
|
|
result = LLVMTypeID::HalfTyID;
|
|
return mlir::success();
|
|
}
|
|
if (mlir::succeeded(matchString(ptr, endPtr, kwBFloat))) {
|
|
result = LLVMTypeID::BFloatTyID;
|
|
return mlir::success();
|
|
}
|
|
if (mlir::succeeded(matchString(ptr, endPtr, kwFloat))) {
|
|
result = LLVMTypeID::FloatTyID;
|
|
return mlir::success();
|
|
}
|
|
if (mlir::succeeded(matchString(ptr, endPtr, kwDouble))) {
|
|
result = LLVMTypeID::DoubleTyID;
|
|
return mlir::success();
|
|
}
|
|
if (mlir::succeeded(matchString(ptr, endPtr, kwX86FP80))) {
|
|
result = LLVMTypeID::X86_FP80TyID;
|
|
return mlir::success();
|
|
}
|
|
if (mlir::succeeded(matchString(ptr, endPtr, kwFP128))) {
|
|
result = LLVMTypeID::FP128TyID;
|
|
return mlir::success();
|
|
}
|
|
if (mlir::succeeded(matchString(ptr, endPtr, kwPPCFP128))) {
|
|
result = LLVMTypeID::PPC_FP128TyID;
|
|
return mlir::success();
|
|
}
|
|
return mlir::failure();
|
|
}
|
|
|
|
fir::KindMapping::KindMapping(mlir::MLIRContext *context, llvm::StringRef map,
|
|
llvm::ArrayRef<KindTy> defs)
|
|
: context{context} {
|
|
if (mlir::failed(setDefaultKinds(defs)))
|
|
llvm::report_fatal_error("bad default kinds");
|
|
if (mlir::failed(parse(map)))
|
|
llvm::report_fatal_error("could not parse kind map");
|
|
}
|
|
|
|
fir::KindMapping::KindMapping(mlir::MLIRContext *context,
|
|
llvm::ArrayRef<KindTy> defs)
|
|
: KindMapping{context, clKindMapping, defs} {}
|
|
|
|
fir::KindMapping::KindMapping(mlir::MLIRContext *context)
|
|
: KindMapping{context, clKindMapping, clDefaultKinds} {}
|
|
|
|
MatchResult fir::KindMapping::badMapString(const llvm::Twine &ptr) {
|
|
auto unknown = mlir::UnknownLoc::get(context);
|
|
mlir::emitError(unknown, ptr);
|
|
return mlir::failure();
|
|
}
|
|
|
|
MatchResult fir::KindMapping::parse(llvm::StringRef kindMap) {
|
|
if (kindMap.empty())
|
|
return mlir::success();
|
|
const char *srcPtr = kindMap.begin();
|
|
const char *endPtr = kindMap.end();
|
|
while (true) {
|
|
char code = '\0';
|
|
KindTy kind = 0;
|
|
if (parseCode(code, srcPtr, endPtr) || parseInt(kind, srcPtr, endPtr))
|
|
return badMapString(srcPtr);
|
|
if (code == 'a' || code == 'i' || code == 'l') {
|
|
Bitsize bits = 0;
|
|
if (parseColon(srcPtr, endPtr) || parseInt(bits, srcPtr, endPtr))
|
|
return badMapString(srcPtr);
|
|
intMap[std::pair<char, KindTy>{code, kind}] = bits;
|
|
} else if (code == 'r' || code == 'c') {
|
|
LLVMTypeID id{};
|
|
if (parseColon(srcPtr, endPtr) || parseTypeID(id, srcPtr, endPtr))
|
|
return badMapString(srcPtr);
|
|
floatMap[std::pair<char, KindTy>{code, kind}] = id;
|
|
} else {
|
|
return badMapString(srcPtr);
|
|
}
|
|
if (parseComma(srcPtr, endPtr))
|
|
break;
|
|
}
|
|
if (srcPtr > endPtr)
|
|
return badMapString(srcPtr);
|
|
return mlir::success();
|
|
}
|
|
|
|
Bitsize fir::KindMapping::getCharacterBitsize(KindTy kind) const {
|
|
return getIntegerLikeBitsize<'a'>(kind, intMap);
|
|
}
|
|
|
|
Bitsize fir::KindMapping::getIntegerBitsize(KindTy kind) const {
|
|
return getIntegerLikeBitsize<'i'>(kind, intMap);
|
|
}
|
|
|
|
Bitsize fir::KindMapping::getLogicalBitsize(KindTy kind) const {
|
|
return getIntegerLikeBitsize<'l'>(kind, intMap);
|
|
}
|
|
|
|
LLVMTypeID fir::KindMapping::getRealTypeID(KindTy kind) const {
|
|
return getFloatLikeTypeID<'r'>(kind, floatMap);
|
|
}
|
|
|
|
LLVMTypeID fir::KindMapping::getComplexTypeID(KindTy kind) const {
|
|
return getFloatLikeTypeID<'c'>(kind, floatMap);
|
|
}
|
|
|
|
Bitsize fir::KindMapping::getRealBitsize(KindTy kind) const {
|
|
auto typeId = getFloatLikeTypeID<'r'>(kind, floatMap);
|
|
llvm::LLVMContext llCtxt; // FIXME
|
|
return llvm::Type::getPrimitiveType(llCtxt, typeId)->getPrimitiveSizeInBits();
|
|
}
|
|
|
|
const llvm::fltSemantics &
|
|
fir::KindMapping::getFloatSemantics(KindTy kind) const {
|
|
return getFloatSemanticsOfKind<'r'>(kind, floatMap);
|
|
}
|
|
|
|
std::string fir::KindMapping::mapToString() const {
|
|
std::string result;
|
|
bool addComma = false;
|
|
for (auto [k, v] : intMap) {
|
|
if (addComma)
|
|
result.append(",");
|
|
else
|
|
addComma = true;
|
|
result += k.first + std::to_string(k.second) + ":" + std::to_string(v);
|
|
}
|
|
for (auto [k, v] : floatMap) {
|
|
if (addComma)
|
|
result.append(",");
|
|
else
|
|
addComma = true;
|
|
result.append(k.first + std::to_string(k.second) + ":");
|
|
switch (v) {
|
|
default:
|
|
llvm_unreachable("unhandled type-id");
|
|
case LLVMTypeID::HalfTyID:
|
|
result.append(kwHalf);
|
|
break;
|
|
case LLVMTypeID::BFloatTyID:
|
|
result.append(kwBFloat);
|
|
break;
|
|
case LLVMTypeID::FloatTyID:
|
|
result.append(kwFloat);
|
|
break;
|
|
case LLVMTypeID::DoubleTyID:
|
|
result.append(kwDouble);
|
|
break;
|
|
case LLVMTypeID::X86_FP80TyID:
|
|
result.append(kwX86FP80);
|
|
break;
|
|
case LLVMTypeID::FP128TyID:
|
|
result.append(kwFP128);
|
|
break;
|
|
case LLVMTypeID::PPC_FP128TyID:
|
|
result.append(kwPPCFP128);
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
mlir::LogicalResult
|
|
fir::KindMapping::setDefaultKinds(llvm::ArrayRef<KindTy> defs) {
|
|
if (defs.empty()) {
|
|
// generic front-end defaults
|
|
const KindTy genericKind = 4;
|
|
defaultMap.insert({'a', 1});
|
|
defaultMap.insert({'c', genericKind});
|
|
defaultMap.insert({'d', 2 * genericKind});
|
|
defaultMap.insert({'i', genericKind});
|
|
defaultMap.insert({'l', genericKind});
|
|
defaultMap.insert({'r', genericKind});
|
|
return mlir::success();
|
|
}
|
|
if (defs.size() != 6)
|
|
return mlir::failure();
|
|
|
|
// defaults determined after command-line processing
|
|
defaultMap.insert({'a', defs[0]});
|
|
defaultMap.insert({'c', defs[1]});
|
|
defaultMap.insert({'d', defs[2]});
|
|
defaultMap.insert({'i', defs[3]});
|
|
defaultMap.insert({'l', defs[4]});
|
|
defaultMap.insert({'r', defs[5]});
|
|
return mlir::success();
|
|
}
|
|
|
|
std::string fir::KindMapping::defaultsToString() const {
|
|
return std::string("a") + std::to_string(defaultMap.find('a')->second) +
|
|
std::string("c") + std::to_string(defaultMap.find('c')->second) +
|
|
std::string("d") + std::to_string(defaultMap.find('d')->second) +
|
|
std::string("i") + std::to_string(defaultMap.find('i')->second) +
|
|
std::string("l") + std::to_string(defaultMap.find('l')->second) +
|
|
std::string("r") + std::to_string(defaultMap.find('r')->second);
|
|
}
|
|
|
|
/// Convert a default intrinsic code into the proper position in the array. The
|
|
/// default kinds have a precise ordering.
|
|
static int codeToIndex(char code) {
|
|
switch (code) {
|
|
case 'a':
|
|
return 0;
|
|
case 'c':
|
|
return 1;
|
|
case 'd':
|
|
return 2;
|
|
case 'i':
|
|
return 3;
|
|
case 'l':
|
|
return 4;
|
|
case 'r':
|
|
return 5;
|
|
}
|
|
llvm_unreachable("invalid default kind intrinsic code");
|
|
}
|
|
|
|
std::vector<KindTy> fir::KindMapping::toDefaultKinds(llvm::StringRef defs) {
|
|
std::vector<KindTy> result(6);
|
|
char code;
|
|
KindTy kind;
|
|
if (defs.empty())
|
|
defs = clDefaultKinds;
|
|
const char *srcPtr = defs.begin();
|
|
const char *endPtr = defs.end();
|
|
while (srcPtr < endPtr) {
|
|
if (parseDefCode(code, srcPtr, endPtr) || parseInt(kind, srcPtr, endPtr))
|
|
llvm::report_fatal_error("invalid default kind code");
|
|
result[codeToIndex(code)] = kind;
|
|
}
|
|
assert(srcPtr == endPtr);
|
|
return result;
|
|
}
|
|
|
|
KindTy fir::KindMapping::defaultCharacterKind() const {
|
|
auto iter = defaultMap.find('a');
|
|
assert(iter != defaultMap.end());
|
|
return iter->second;
|
|
}
|
|
|
|
KindTy fir::KindMapping::defaultComplexKind() const {
|
|
auto iter = defaultMap.find('c');
|
|
assert(iter != defaultMap.end());
|
|
return iter->second;
|
|
}
|
|
|
|
KindTy fir::KindMapping::defaultDoubleKind() const {
|
|
auto iter = defaultMap.find('d');
|
|
assert(iter != defaultMap.end());
|
|
return iter->second;
|
|
}
|
|
|
|
KindTy fir::KindMapping::defaultIntegerKind() const {
|
|
auto iter = defaultMap.find('i');
|
|
assert(iter != defaultMap.end());
|
|
return iter->second;
|
|
}
|
|
|
|
KindTy fir::KindMapping::defaultLogicalKind() const {
|
|
auto iter = defaultMap.find('l');
|
|
assert(iter != defaultMap.end());
|
|
return iter->second;
|
|
}
|
|
|
|
KindTy fir::KindMapping::defaultRealKind() const {
|
|
auto iter = defaultMap.find('r');
|
|
assert(iter != defaultMap.end());
|
|
return iter->second;
|
|
}
|