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 return prefix().append("C").append(toLower(name)); 104 } 105 106 std::string 107 fir::NameUniquer::doConstant(llvm::ArrayRef<llvm::StringRef> modules, 108 llvm::ArrayRef<llvm::StringRef> procs, 109 std::int64_t blockId, llvm::StringRef name) { 110 return prefix() 111 .append(doAncestors(modules, procs, blockId)) 112 .append("EC") 113 .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 return prefix() 122 .append(doAncestors(modules, procs, blockId)) 123 .append("DT") 124 .append(toLower(name)) 125 .append(doKinds(kinds)); 126 } 127 128 std::string fir::NameUniquer::doGenerated(llvm::StringRef name) { 129 return prefix().append("Q").append(name); 130 } 131 132 std::string 133 fir::NameUniquer::doGenerated(llvm::ArrayRef<llvm::StringRef> modules, 134 llvm::ArrayRef<llvm::StringRef> procs, 135 std::int64_t blockId, llvm::StringRef name) { 136 return prefix() 137 .append("Q") 138 .append(doAncestors(modules, procs, blockId)) 139 .append(name); 140 } 141 142 std::string fir::NameUniquer::doIntrinsicTypeDescriptor( 143 llvm::ArrayRef<llvm::StringRef> modules, 144 llvm::ArrayRef<llvm::StringRef> procs, std::int64_t blockId, 145 IntrinsicType type, std::int64_t kind) { 146 const char *name = nullptr; 147 switch (type) { 148 case IntrinsicType::CHARACTER: 149 name = "character"; 150 break; 151 case IntrinsicType::COMPLEX: 152 name = "complex"; 153 break; 154 case IntrinsicType::INTEGER: 155 name = "integer"; 156 break; 157 case IntrinsicType::LOGICAL: 158 name = "logical"; 159 break; 160 case IntrinsicType::REAL: 161 name = "real"; 162 break; 163 } 164 assert(name && "unknown intrinsic type"); 165 return prefix() 166 .append(doAncestors(modules, procs, blockId)) 167 .append("YI") 168 .append(name) 169 .append(doKind(kind)); 170 } 171 172 std::string 173 fir::NameUniquer::doProcedure(llvm::ArrayRef<llvm::StringRef> modules, 174 llvm::ArrayRef<llvm::StringRef> procs, 175 llvm::StringRef name) { 176 return prefix() 177 .append(doAncestors(modules, procs)) 178 .append("P") 179 .append(toLower(name)); 180 } 181 182 std::string fir::NameUniquer::doType(llvm::ArrayRef<llvm::StringRef> modules, 183 llvm::ArrayRef<llvm::StringRef> procs, 184 std::int64_t blockId, llvm::StringRef name, 185 llvm::ArrayRef<std::int64_t> kinds) { 186 return prefix() 187 .append(doAncestors(modules, procs, blockId)) 188 .append("T") 189 .append(toLower(name)) 190 .append(doKinds(kinds)); 191 } 192 193 std::string 194 fir::NameUniquer::doTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules, 195 llvm::ArrayRef<llvm::StringRef> procs, 196 std::int64_t blockId, llvm::StringRef name, 197 llvm::ArrayRef<std::int64_t> kinds) { 198 return prefix() 199 .append(doAncestors(modules, procs, blockId)) 200 .append("CT") 201 .append(toLower(name)) 202 .append(doKinds(kinds)); 203 } 204 205 std::string 206 fir::NameUniquer::doTypeDescriptor(llvm::ArrayRef<std::string> modules, 207 llvm::ArrayRef<std::string> procs, 208 std::int64_t blockId, llvm::StringRef name, 209 llvm::ArrayRef<std::int64_t> kinds) { 210 auto rmodules = convertToStringRef(modules); 211 auto rprocs = convertToStringRef(procs); 212 return doTypeDescriptor(rmodules, rprocs, blockId, name, kinds); 213 } 214 215 std::string 216 fir::NameUniquer::doVariable(llvm::ArrayRef<llvm::StringRef> modules, 217 llvm::ArrayRef<llvm::StringRef> procs, 218 std::int64_t blockId, llvm::StringRef name) { 219 return prefix() 220 .append(doAncestors(modules, procs, blockId)) 221 .append("E") 222 .append(toLower(name)); 223 } 224 225 std::string 226 fir::NameUniquer::doNamelistGroup(llvm::ArrayRef<llvm::StringRef> modules, 227 llvm::ArrayRef<llvm::StringRef> procs, 228 llvm::StringRef name) { 229 return prefix() 230 .append(doAncestors(modules, procs)) 231 .append("N") 232 .append(toLower(name)); 233 } 234 235 llvm::StringRef fir::NameUniquer::doProgramEntry() { 236 if (mainEntryName.size()) 237 return mainEntryName; 238 return "_QQmain"; 239 } 240 241 std::pair<fir::NameUniquer::NameKind, fir::NameUniquer::DeconstructedName> 242 fir::NameUniquer::deconstruct(llvm::StringRef uniq) { 243 if (uniq.starts_with("_Q")) { 244 llvm::SmallVector<std::string> modules; 245 llvm::SmallVector<std::string> procs; 246 std::int64_t blockId = 0; 247 std::string name; 248 llvm::SmallVector<std::int64_t> kinds; 249 NameKind nk = NameKind::NOT_UNIQUED; 250 for (std::size_t i = 2, end{uniq.size()}; i != end;) { 251 switch (uniq[i]) { 252 case 'B': // Block 253 blockId = readInt(uniq, i, i + 1, end); 254 break; 255 case 'C': // Common block 256 nk = NameKind::COMMON; 257 name = readName(uniq, i, i + 1, end); 258 break; 259 case 'D': // Dispatch table 260 nk = NameKind::DISPATCH_TABLE; 261 assert(uniq[i + 1] == 'T'); 262 name = readName(uniq, i, i + 2, end); 263 break; 264 case 'E': 265 if (uniq[i + 1] == 'C') { // Constant Entity 266 nk = NameKind::CONSTANT; 267 name = readName(uniq, i, i + 2, end); 268 } else { // variable Entity 269 nk = NameKind::VARIABLE; 270 name = readName(uniq, i, i + 1, end); 271 } 272 break; 273 case 'F': // procedure/Function ancestor component of a mangled prefix 274 procs.push_back(readName(uniq, i, i + 1, end)); 275 break; 276 case 'K': 277 if (uniq[i + 1] == 'N') // Negative Kind 278 kinds.push_back(-readInt(uniq, i, i + 2, end)); 279 else // [positive] Kind 280 kinds.push_back(readInt(uniq, i, i + 1, end)); 281 break; 282 case 'M': // Module 283 case 'S': // Submodule 284 modules.push_back(readName(uniq, i, i + 1, end)); 285 break; 286 case 'N': // Namelist group 287 nk = NameKind::NAMELIST_GROUP; 288 name = readName(uniq, i, i + 1, end); 289 break; 290 case 'P': // Procedure/function (itself) 291 nk = NameKind::PROCEDURE; 292 name = readName(uniq, i, i + 1, end); 293 break; 294 case 'Q': // UniQue mangle name tag 295 nk = NameKind::GENERATED; 296 name = uniq; 297 i = end; 298 break; 299 case 'T': // derived Type 300 nk = NameKind::DERIVED_TYPE; 301 name = readName(uniq, i, i + 1, end); 302 break; 303 case 'Y': 304 if (uniq[i + 1] == 'I') { // tYpe descriptor for an Intrinsic type 305 nk = NameKind::INTRINSIC_TYPE_DESC; 306 name = readName(uniq, i, i + 1, end); 307 } else { // tYpe descriptor 308 nk = NameKind::TYPE_DESC; 309 name = readName(uniq, i, i + 2, end); 310 } 311 break; 312 default: 313 assert(false && "unknown uniquing code"); 314 break; 315 } 316 } 317 return {nk, DeconstructedName(modules, procs, blockId, name, kinds)}; 318 } 319 return {NameKind::NOT_UNIQUED, DeconstructedName(uniq)}; 320 } 321 322 bool fir::NameUniquer::isExternalFacingUniquedName( 323 const std::pair<fir::NameUniquer::NameKind, 324 fir::NameUniquer::DeconstructedName> &deconstructResult) { 325 return (deconstructResult.first == NameKind::PROCEDURE || 326 deconstructResult.first == NameKind::COMMON) && 327 deconstructResult.second.modules.empty() && 328 deconstructResult.second.procs.empty(); 329 } 330 331 bool fir::NameUniquer::needExternalNameMangling(llvm::StringRef uniquedName) { 332 auto result = fir::NameUniquer::deconstruct(uniquedName); 333 return result.first != fir::NameUniquer::NameKind::NOT_UNIQUED && 334 fir::NameUniquer::isExternalFacingUniquedName(result); 335 } 336 337 bool fir::NameUniquer::belongsToModule(llvm::StringRef uniquedName, 338 llvm::StringRef moduleName) { 339 auto result = fir::NameUniquer::deconstruct(uniquedName); 340 return !result.second.modules.empty() && 341 result.second.modules[0] == moduleName; 342 } 343 344 static std::string 345 mangleTypeDescriptorKinds(llvm::ArrayRef<std::int64_t> kinds) { 346 if (kinds.empty()) 347 return ""; 348 std::string result; 349 for (std::int64_t kind : kinds) 350 result += "." + std::to_string(kind); 351 return result; 352 } 353 354 static std::string getDerivedTypeObjectName(llvm::StringRef mangledTypeName, 355 const llvm::StringRef separator) { 356 if (mangledTypeName.ends_with(boxprocSuffix)) 357 mangledTypeName = mangledTypeName.drop_back(boxprocSuffix.size()); 358 auto result = fir::NameUniquer::deconstruct(mangledTypeName); 359 if (result.first != fir::NameUniquer::NameKind::DERIVED_TYPE) 360 return ""; 361 std::string varName = separator.str() + result.second.name + 362 mangleTypeDescriptorKinds(result.second.kinds); 363 llvm::SmallVector<llvm::StringRef> modules; 364 for (const std::string &mod : result.second.modules) 365 modules.push_back(mod); 366 llvm::SmallVector<llvm::StringRef> procs; 367 for (const std::string &proc : result.second.procs) 368 procs.push_back(proc); 369 return fir::NameUniquer::doVariable(modules, procs, result.second.blockId, 370 varName); 371 } 372 373 std::string 374 fir::NameUniquer::getTypeDescriptorName(llvm::StringRef mangledTypeName) { 375 return getDerivedTypeObjectName(mangledTypeName, typeDescriptorSeparator); 376 } 377 378 std::string fir::NameUniquer::getTypeDescriptorBindingTableName( 379 llvm::StringRef mangledTypeName) { 380 return getDerivedTypeObjectName(mangledTypeName, bindingTableSeparator); 381 } 382