| //===-- 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/Dialect/Support/KindMapping.h" | |
| #include "llvm/IR/LLVMContext.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 bitsInByte = 8; | |
| return kind * bitsInByte; | |
| } | |
| /// 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 INTEGER, 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 llvm::LogicalResult matchString(const char *&ptr, const char *endPtr, | |
| llvm::StringRef literal) { | |
| llvm::StringRef s(ptr, endPtr - ptr); | |
| if (s.starts_with(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; | |
| } | |
| llvm::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; | |
| } |