flang/lib/Optimizer/Support/InternalNames.cpp

   1 //===-- InternalNames.cpp -------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "flang/Optimizer/Support/InternalNames.h"
  14 #include "flang/Optimizer/Dialect/FIRType.h"
  15 #include "mlir/IR/BuiltinTypes.h"
  16 #include "mlir/IR/Diagnostics.h"
  17 #include "llvm/Support/CommandLine.h"
  18 #include <optional>
  19
  20 static llvm::cl::opt<std::string> mainEntryName(
  21     "main-entry-name",
  22     llvm::cl::desc("override the name of the default PROGRAM entry (may be "
  23                    "helpful for using other runtimes)"));
  24
  25 constexpr std::int64_t badValue = -1;
  26
  27 inline std::string prefix() { return "_Q"; }
  28
  29 /// Generate a mangling prefix from module, submodule, procedure, and
  30 /// statement function names, plus an (innermost) block scope id.
  31 static std::string doAncestors(llvm::ArrayRef<llvm::StringRef> modules,
  32                                llvm::ArrayRef<llvm::StringRef> procs,
  33                                std::int64_t blockId = 0) {
  34   std::string prefix;
  35   const char *tag = "M";
  36   for (auto mod : modules) {
  37     prefix.append(tag).append(mod.lower());
  38     tag = "S";
  39   }
  40   for (auto proc : procs)
  41     prefix.append("F").append(proc.lower());
  42   if (blockId)
  43     prefix.append("B").append(std::to_string(blockId));
  44   return prefix;
  45 }
  46
  47 inline llvm::SmallVector<llvm::StringRef>
  48 convertToStringRef(llvm::ArrayRef<std::string> from) {
  49   return {from.begin(), from.end()};
  50 }
  51
  52 inline std::optional<llvm::StringRef>
  53 convertToStringRef(const std::optional<std::string> &from) {
  54   std::optional<llvm::StringRef> to;
  55   if (from)
  56     to = *from;
  57   return to;
  58 }
  59
  60 static std::string readName(llvm::StringRef uniq, std::size_t &i,
  61                             std::size_t init, std::size_t end) {
  62   for (i = init; i < end && (uniq[i] < 'A' || uniq[i] > 'Z'); ++i) {
  63     // do nothing
  64   }
  65   return uniq.substr(init, i - init).str();
  66 }
  67
  68 static std::int64_t readInt(llvm::StringRef uniq, std::size_t &i,
  69                             std::size_t init, std::size_t end) {
  70   for (i = init; i < end && uniq[i] >= '0' && uniq[i] <= '9'; ++i) {
  71     // do nothing
  72   }
  73   std::int64_t result = badValue;
  74   if (uniq.substr(init, i - init).getAsInteger(10, result))
  75     return badValue;
  76   return result;
  77 }
  78
  79 std::string fir::NameUniquer::toLower(llvm::StringRef name) {
  80   return name.lower();
  81 }
  82
  83 std::string fir::NameUniquer::intAsString(std::int64_t i) {
  84   assert(i >= 0);
  85   return std::to_string(i);
  86 }
  87
  88 std::string fir::NameUniquer::doKind(std::int64_t kind) {
  89   std::string result = "K";
  90   if (kind < 0)
  91     return result.append("N").append(intAsString(-kind));
  92   return result.append(intAsString(kind));
  93 }
  94
  95 std::string fir::NameUniquer::doKinds(llvm::ArrayRef<std::int64_t> kinds) {
  96   std::string result;
  97   for (auto i : kinds)
  98     result.append(doKind(i));
  99   return result;
 100 }
 101
 102 std::string fir::NameUniquer::doCommonBlock(llvm::StringRef name) {
 103   std::string result = prefix();
 104   return result.append("C").append(toLower(name));
 105 }
 106
 107 std::string
 108 fir::NameUniquer::doConstant(llvm::ArrayRef<llvm::StringRef> modules,
 109                              llvm::ArrayRef<llvm::StringRef> procs,
 110                              std::int64_t blockId, llvm::StringRef name) {
 111   std::string result = prefix();
 112   result.append(doAncestors(modules, procs, blockId)).append("EC");
 113   return result.append(toLower(name));
 114 }
 115
 116 std::string
 117 fir::NameUniquer::doDispatchTable(llvm::ArrayRef<llvm::StringRef> modules,
 118                                   llvm::ArrayRef<llvm::StringRef> procs,
 119                                   std::int64_t blockId, llvm::StringRef name,
 120                                   llvm::ArrayRef<std::int64_t> kinds) {
 121   std::string result = prefix();
 122   result.append(doAncestors(modules, procs, blockId)).append("DT");
 123   return result.append(toLower(name)).append(doKinds(kinds));
 124 }
 125
 126 std::string fir::NameUniquer::doGenerated(llvm::StringRef name) {
 127   std::string result = prefix();
 128   return result.append("Q").append(name);
 129 }
 130
 131 std::string fir::NameUniquer::doIntrinsicTypeDescriptor(
 132     llvm::ArrayRef<llvm::StringRef> modules,
 133     llvm::ArrayRef<llvm::StringRef> procs, std::int64_t blockId,
 134     IntrinsicType type, std::int64_t kind) {
 135   const char *name = nullptr;
 136   switch (type) {
 137   case IntrinsicType::CHARACTER:
 138     name = "character";
 139     break;
 140   case IntrinsicType::COMPLEX:
 141     name = "complex";
 142     break;
 143   case IntrinsicType::INTEGER:
 144     name = "integer";
 145     break;
 146   case IntrinsicType::LOGICAL:
 147     name = "logical";
 148     break;
 149   case IntrinsicType::REAL:
 150     name = "real";
 151     break;
 152   }
 153   assert(name && "unknown intrinsic type");
 154   std::string result = prefix();
 155   result.append(doAncestors(modules, procs, blockId)).append("YI");
 156   return result.append(name).append(doKind(kind));
 157 }
 158
 159 std::string
 160 fir::NameUniquer::doProcedure(llvm::ArrayRef<llvm::StringRef> modules,
 161                               llvm::ArrayRef<llvm::StringRef> procs,
 162                               llvm::StringRef name) {
 163   std::string result = prefix();
 164   result.append(doAncestors(modules, procs)).append("P");
 165   return result.append(toLower(name));
 166 }
 167
 168 std::string fir::NameUniquer::doType(llvm::ArrayRef<llvm::StringRef> modules,
 169                                      llvm::ArrayRef<llvm::StringRef> procs,
 170                                      std::int64_t blockId, llvm::StringRef name,
 171                                      llvm::ArrayRef<std::int64_t> kinds) {
 172   std::string result = prefix();
 173   result.append(doAncestors(modules, procs, blockId)).append("T");
 174   return result.append(toLower(name)).append(doKinds(kinds));
 175 }
 176
 177 std::string
 178 fir::NameUniquer::doTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
 179                                    llvm::ArrayRef<llvm::StringRef> procs,
 180                                    std::int64_t blockId, llvm::StringRef name,
 181                                    llvm::ArrayRef<std::int64_t> kinds) {
 182   std::string result = prefix();
 183   result.append(doAncestors(modules, procs, blockId)).append("CT");
 184   return result.append(toLower(name)).append(doKinds(kinds));
 185 }
 186
 187 std::string
 188 fir::NameUniquer::doTypeDescriptor(llvm::ArrayRef<std::string> modules,
 189                                    llvm::ArrayRef<std::string> procs,
 190                                    std::int64_t blockId, llvm::StringRef name,
 191                                    llvm::ArrayRef<std::int64_t> kinds) {
 192   auto rmodules = convertToStringRef(modules);
 193   auto rprocs = convertToStringRef(procs);
 194   return doTypeDescriptor(rmodules, rprocs, blockId, name, kinds);
 195 }
 196
 197 std::string
 198 fir::NameUniquer::doVariable(llvm::ArrayRef<llvm::StringRef> modules,
 199                              llvm::ArrayRef<llvm::StringRef> procs,
 200                              std::int64_t blockId, llvm::StringRef name) {
 201   std::string result = prefix();
 202   result.append(doAncestors(modules, procs, blockId)).append("E");
 203   return result.append(toLower(name));
 204 }
 205
 206 std::string
 207 fir::NameUniquer::doNamelistGroup(llvm::ArrayRef<llvm::StringRef> modules,
 208                                   llvm::ArrayRef<llvm::StringRef> procs,
 209                                   llvm::StringRef name) {
 210   std::string result = prefix();
 211   result.append(doAncestors(modules, procs)).append("N");
 212   return result.append(toLower(name));
 213 }
 214
 215 llvm::StringRef fir::NameUniquer::doProgramEntry() {
 216   if (mainEntryName.size())
 217     return mainEntryName;
 218   return "_QQmain";
 219 }
 220
 221 std::pair<fir::NameUniquer::NameKind, fir::NameUniquer::DeconstructedName>
 222 fir::NameUniquer::deconstruct(llvm::StringRef uniq) {
 223   if (uniq.startswith("_Q")) {
 224     llvm::SmallVector<std::string> modules;
 225     llvm::SmallVector<std::string> procs;
 226     std::int64_t blockId = 0;
 227     std::string name;
 228     llvm::SmallVector<std::int64_t> kinds;
 229     NameKind nk = NameKind::NOT_UNIQUED;
 230     for (std::size_t i = 2, end{uniq.size()}; i != end;) {
 231       switch (uniq[i]) {
 232       case 'B': // Block
 233         blockId = readInt(uniq, i, i + 1, end);
 234         break;
 235       case 'C': // Common block
 236         nk = NameKind::COMMON;
 237         name = readName(uniq, i, i + 1, end);
 238         break;
 239       case 'D': // Dispatch table
 240         nk = NameKind::DISPATCH_TABLE;
 241         assert(uniq[i + 1] == 'T');
 242         name = readName(uniq, i, i + 2, end);
 243         break;
 244       case 'E':
 245         if (uniq[i + 1] == 'C') { // Constant Entity
 246           nk = NameKind::CONSTANT;
 247           name = readName(uniq, i, i + 2, end);
 248         } else { // variable Entity
 249           nk = NameKind::VARIABLE;
 250           name = readName(uniq, i, i + 1, end);
 251         }
 252         break;
 253       case 'F': // procedure/Function ancestor component of a mangled prefix
 254         procs.push_back(readName(uniq, i, i + 1, end));
 255         break;
 256       case 'K':
 257         if (uniq[i + 1] == 'N') // Negative Kind
 258           kinds.push_back(-readInt(uniq, i, i + 2, end));
 259         else // [positive] Kind
 260           kinds.push_back(readInt(uniq, i, i + 1, end));
 261         break;
 262       case 'M': // Module
 263       case 'S': // Submodule
 264         modules.push_back(readName(uniq, i, i + 1, end));
 265         break;
 266       case 'N': // Namelist group
 267         nk = NameKind::NAMELIST_GROUP;
 268         name = readName(uniq, i, i + 1, end);
 269         break;
 270       case 'P': // Procedure/function (itself)
 271         nk = NameKind::PROCEDURE;
 272         name = readName(uniq, i, i + 1, end);
 273         break;
 274       case 'Q': // UniQue mangle name tag
 275         nk = NameKind::GENERATED;
 276         name = uniq;
 277         i = end;
 278         break;
 279       case 'T': // derived Type
 280         nk = NameKind::DERIVED_TYPE;
 281         name = readName(uniq, i, i + 1, end);
 282         break;
 283       case 'Y':
 284         if (uniq[i + 1] == 'I') { // tYpe descriptor for an Intrinsic type
 285           nk = NameKind::INTRINSIC_TYPE_DESC;
 286           name = readName(uniq, i, i + 1, end);
 287         } else { // tYpe descriptor
 288           nk = NameKind::TYPE_DESC;
 289           name = readName(uniq, i, i + 2, end);
 290         }
 291         break;
 292       default:
 293         assert(false && "unknown uniquing code");
 294         break;
 295       }
 296     }
 297     return {nk, DeconstructedName(modules, procs, blockId, name, kinds)};
 298   }
 299   return {NameKind::NOT_UNIQUED, DeconstructedName(uniq)};
 300 }
 301
 302 bool fir::NameUniquer::isExternalFacingUniquedName(
 303     const std::pair<fir::NameUniquer::NameKind,
 304                     fir::NameUniquer::DeconstructedName> &deconstructResult) {
 305   return (deconstructResult.first == NameKind::PROCEDURE ||
 306           deconstructResult.first == NameKind::COMMON) &&
 307          deconstructResult.second.modules.empty() &&
 308          deconstructResult.second.procs.empty();
 309 }
 310
 311 bool fir::NameUniquer::needExternalNameMangling(llvm::StringRef uniquedName) {
 312   auto result = fir::NameUniquer::deconstruct(uniquedName);
 313   return result.first != fir::NameUniquer::NameKind::NOT_UNIQUED &&
 314          fir::NameUniquer::isExternalFacingUniquedName(result);
 315 }
 316
 317 bool fir::NameUniquer::belongsToModule(llvm::StringRef uniquedName,
 318                                        llvm::StringRef moduleName) {
 319   auto result = fir::NameUniquer::deconstruct(uniquedName);
 320   return !result.second.modules.empty() &&
 321          result.second.modules[0] == moduleName;
 322 }
 323
 324 static std::string
 325 mangleTypeDescriptorKinds(llvm::ArrayRef<std::int64_t> kinds) {
 326   if (kinds.empty())
 327     return "";
 328   std::string result;
 329   for (std::int64_t kind : kinds)
 330     result += "." + std::to_string(kind);
 331   return result;
 332 }
 333
 334 static std::string getDerivedTypeObjectName(llvm::StringRef mangledTypeName,
 335                                             const llvm::StringRef separator) {
 336   if (mangledTypeName.ends_with(boxprocSuffix))
 337     mangledTypeName = mangledTypeName.drop_back(boxprocSuffix.size());
 338   auto result = fir::NameUniquer::deconstruct(mangledTypeName);
 339   if (result.first != fir::NameUniquer::NameKind::DERIVED_TYPE)
 340     return "";
 341   std::string varName = separator.str() + result.second.name +
 342                         mangleTypeDescriptorKinds(result.second.kinds);
 343   llvm::SmallVector<llvm::StringRef> modules;
 344   for (const std::string &mod : result.second.modules)
 345     modules.push_back(mod);
 346   llvm::SmallVector<llvm::StringRef> procs;
 347   for (const std::string &proc : result.second.procs)
 348     procs.push_back(proc);
 349   return fir::NameUniquer::doVariable(modules, procs, result.second.blockId,
 350                                       varName);
 351 }
 352
 353 std::string
 354 fir::NameUniquer::getTypeDescriptorName(llvm::StringRef mangledTypeName) {
 355   return getDerivedTypeObjectName(mangledTypeName, typeDescriptorSeparator);
 356 }
 357
 358 std::string fir::NameUniquer::getTypeDescriptorBindingTableName(
 359     llvm::StringRef mangledTypeName) {
 360   return getDerivedTypeObjectName(mangledTypeName, bindingTableSeparator);
 361 }