1 //===- MipsArchTree.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 // This file contains a helper function for the Writer. 10 // 11 //===---------------------------------------------------------------------===// 12 13 #include "InputFiles.h" 14 #include "SymbolTable.h" 15 #include "Writer.h" 16 17 #include "lld/Common/ErrorHandler.h" 18 #include "llvm/BinaryFormat/ELF.h" 19 #include "llvm/Support/MipsABIFlags.h" 20 21 using namespace llvm; 22 using namespace llvm::object; 23 using namespace llvm::ELF; 24 25 using namespace lld; 26 using namespace lld::elf; 27 28 namespace { 29 struct ArchTreeEdge { 30 uint32_t child; 31 uint32_t parent; 32 }; 33 34 struct FileFlags { 35 InputFile *file; 36 uint32_t flags; 37 }; 38 } // namespace 39 40 static StringRef getAbiName(uint32_t flags) { 41 switch (flags) { 42 case 0: 43 return "n64"; 44 case EF_MIPS_ABI2: 45 return "n32"; 46 case EF_MIPS_ABI_O32: 47 return "o32"; 48 case EF_MIPS_ABI_O64: 49 return "o64"; 50 case EF_MIPS_ABI_EABI32: 51 return "eabi32"; 52 case EF_MIPS_ABI_EABI64: 53 return "eabi64"; 54 default: 55 return "unknown"; 56 } 57 } 58 59 static StringRef getNanName(bool isNan2008) { 60 return isNan2008 ? "2008" : "legacy"; 61 } 62 63 static StringRef getFpName(bool isFp64) { return isFp64 ? "64" : "32"; } 64 65 static void checkFlags(ArrayRef<FileFlags> files) { 66 assert(!files.empty() && "expected non-empty file list"); 67 68 uint32_t abi = files[0].flags & (EF_MIPS_ABI | EF_MIPS_ABI2); 69 bool nan = files[0].flags & EF_MIPS_NAN2008; 70 bool fp = files[0].flags & EF_MIPS_FP64; 71 72 for (const FileFlags &f : files) { 73 if (config->is64 && f.flags & EF_MIPS_MICROMIPS) 74 error(toString(f.file) + ": microMIPS 64-bit is not supported"); 75 76 uint32_t abi2 = f.flags & (EF_MIPS_ABI | EF_MIPS_ABI2); 77 if (abi != abi2) 78 error(toString(f.file) + ": ABI '" + getAbiName(abi2) + 79 "' is incompatible with target ABI '" + getAbiName(abi) + "'"); 80 81 bool nan2 = f.flags & EF_MIPS_NAN2008; 82 if (nan != nan2) 83 error(toString(f.file) + ": -mnan=" + getNanName(nan2) + 84 " is incompatible with target -mnan=" + getNanName(nan)); 85 86 bool fp2 = f.flags & EF_MIPS_FP64; 87 if (fp != fp2) 88 error(toString(f.file) + ": -mfp" + getFpName(fp2) + 89 " is incompatible with target -mfp" + getFpName(fp)); 90 } 91 } 92 93 static uint32_t getMiscFlags(ArrayRef<FileFlags> files) { 94 uint32_t ret = 0; 95 for (const FileFlags &f : files) 96 ret |= f.flags & 97 (EF_MIPS_ABI | EF_MIPS_ABI2 | EF_MIPS_ARCH_ASE | EF_MIPS_NOREORDER | 98 EF_MIPS_MICROMIPS | EF_MIPS_NAN2008 | EF_MIPS_32BITMODE); 99 return ret; 100 } 101 102 static uint32_t getPicFlags(ArrayRef<FileFlags> files) { 103 // Check PIC/non-PIC compatibility. 104 bool isPic = files[0].flags & (EF_MIPS_PIC | EF_MIPS_CPIC); 105 for (const FileFlags &f : files.slice(1)) { 106 bool isPic2 = f.flags & (EF_MIPS_PIC | EF_MIPS_CPIC); 107 if (isPic && !isPic2) 108 warn(toString(f.file) + 109 ": linking non-abicalls code with abicalls code " + 110 toString(files[0].file)); 111 if (!isPic && isPic2) 112 warn(toString(f.file) + 113 ": linking abicalls code with non-abicalls code " + 114 toString(files[0].file)); 115 } 116 117 // Compute the result PIC/non-PIC flag. 118 uint32_t ret = files[0].flags & (EF_MIPS_PIC | EF_MIPS_CPIC); 119 for (const FileFlags &f : files.slice(1)) 120 ret &= f.flags & (EF_MIPS_PIC | EF_MIPS_CPIC); 121 122 // PIC code is inherently CPIC and may not set CPIC flag explicitly. 123 if (ret & EF_MIPS_PIC) 124 ret |= EF_MIPS_CPIC; 125 return ret; 126 } 127 128 static ArchTreeEdge archTree[] = { 129 // MIPS32R6 and MIPS64R6 are not compatible with other extensions 130 // MIPS64R2 extensions. 131 {EF_MIPS_ARCH_64R2 | EF_MIPS_MACH_OCTEON3, EF_MIPS_ARCH_64R2}, 132 {EF_MIPS_ARCH_64R2 | EF_MIPS_MACH_OCTEON2, EF_MIPS_ARCH_64R2}, 133 {EF_MIPS_ARCH_64R2 | EF_MIPS_MACH_OCTEON, EF_MIPS_ARCH_64R2}, 134 {EF_MIPS_ARCH_64R2 | EF_MIPS_MACH_LS3A, EF_MIPS_ARCH_64R2}, 135 // MIPS64 extensions. 136 {EF_MIPS_ARCH_64 | EF_MIPS_MACH_SB1, EF_MIPS_ARCH_64}, 137 {EF_MIPS_ARCH_64 | EF_MIPS_MACH_XLR, EF_MIPS_ARCH_64}, 138 {EF_MIPS_ARCH_64R2, EF_MIPS_ARCH_64}, 139 // MIPS V extensions. 140 {EF_MIPS_ARCH_64, EF_MIPS_ARCH_5}, 141 // R5000 extensions. 142 {EF_MIPS_ARCH_4 | EF_MIPS_MACH_5500, EF_MIPS_ARCH_4 | EF_MIPS_MACH_5400}, 143 // MIPS IV extensions. 144 {EF_MIPS_ARCH_4 | EF_MIPS_MACH_5400, EF_MIPS_ARCH_4}, 145 {EF_MIPS_ARCH_4 | EF_MIPS_MACH_9000, EF_MIPS_ARCH_4}, 146 {EF_MIPS_ARCH_5, EF_MIPS_ARCH_4}, 147 // VR4100 extensions. 148 {EF_MIPS_ARCH_3 | EF_MIPS_MACH_4111, EF_MIPS_ARCH_3 | EF_MIPS_MACH_4100}, 149 {EF_MIPS_ARCH_3 | EF_MIPS_MACH_4120, EF_MIPS_ARCH_3 | EF_MIPS_MACH_4100}, 150 // MIPS III extensions. 151 {EF_MIPS_ARCH_3 | EF_MIPS_MACH_4010, EF_MIPS_ARCH_3}, 152 {EF_MIPS_ARCH_3 | EF_MIPS_MACH_4100, EF_MIPS_ARCH_3}, 153 {EF_MIPS_ARCH_3 | EF_MIPS_MACH_4650, EF_MIPS_ARCH_3}, 154 {EF_MIPS_ARCH_3 | EF_MIPS_MACH_5900, EF_MIPS_ARCH_3}, 155 {EF_MIPS_ARCH_3 | EF_MIPS_MACH_LS2E, EF_MIPS_ARCH_3}, 156 {EF_MIPS_ARCH_3 | EF_MIPS_MACH_LS2F, EF_MIPS_ARCH_3}, 157 {EF_MIPS_ARCH_4, EF_MIPS_ARCH_3}, 158 // MIPS32 extensions. 159 {EF_MIPS_ARCH_32R2, EF_MIPS_ARCH_32}, 160 // MIPS II extensions. 161 {EF_MIPS_ARCH_3, EF_MIPS_ARCH_2}, 162 {EF_MIPS_ARCH_32, EF_MIPS_ARCH_2}, 163 // MIPS I extensions. 164 {EF_MIPS_ARCH_1 | EF_MIPS_MACH_3900, EF_MIPS_ARCH_1}, 165 {EF_MIPS_ARCH_2, EF_MIPS_ARCH_1}, 166 }; 167 168 static bool isArchMatched(uint32_t newFlags, uint32_t res) { 169 if (newFlags == res) 170 return true; 171 if (newFlags == EF_MIPS_ARCH_32 && isArchMatched(EF_MIPS_ARCH_64, res)) 172 return true; 173 if (newFlags == EF_MIPS_ARCH_32R2 && isArchMatched(EF_MIPS_ARCH_64R2, res)) 174 return true; 175 for (const auto &edge : archTree) { 176 if (res == edge.child) { 177 res = edge.parent; 178 if (res == newFlags) 179 return true; 180 } 181 } 182 return false; 183 } 184 185 static StringRef getMachName(uint32_t flags) { 186 switch (flags & EF_MIPS_MACH) { 187 case EF_MIPS_MACH_NONE: 188 return ""; 189 case EF_MIPS_MACH_3900: 190 return "r3900"; 191 case EF_MIPS_MACH_4010: 192 return "r4010"; 193 case EF_MIPS_MACH_4100: 194 return "r4100"; 195 case EF_MIPS_MACH_4650: 196 return "r4650"; 197 case EF_MIPS_MACH_4120: 198 return "r4120"; 199 case EF_MIPS_MACH_4111: 200 return "r4111"; 201 case EF_MIPS_MACH_5400: 202 return "vr5400"; 203 case EF_MIPS_MACH_5900: 204 return "vr5900"; 205 case EF_MIPS_MACH_5500: 206 return "vr5500"; 207 case EF_MIPS_MACH_9000: 208 return "rm9000"; 209 case EF_MIPS_MACH_LS2E: 210 return "loongson2e"; 211 case EF_MIPS_MACH_LS2F: 212 return "loongson2f"; 213 case EF_MIPS_MACH_LS3A: 214 return "loongson3a"; 215 case EF_MIPS_MACH_OCTEON: 216 return "octeon"; 217 case EF_MIPS_MACH_OCTEON2: 218 return "octeon2"; 219 case EF_MIPS_MACH_OCTEON3: 220 return "octeon3"; 221 case EF_MIPS_MACH_SB1: 222 return "sb1"; 223 case EF_MIPS_MACH_XLR: 224 return "xlr"; 225 default: 226 return "unknown machine"; 227 } 228 } 229 230 static StringRef getArchName(uint32_t flags) { 231 switch (flags & EF_MIPS_ARCH) { 232 case EF_MIPS_ARCH_1: 233 return "mips1"; 234 case EF_MIPS_ARCH_2: 235 return "mips2"; 236 case EF_MIPS_ARCH_3: 237 return "mips3"; 238 case EF_MIPS_ARCH_4: 239 return "mips4"; 240 case EF_MIPS_ARCH_5: 241 return "mips5"; 242 case EF_MIPS_ARCH_32: 243 return "mips32"; 244 case EF_MIPS_ARCH_64: 245 return "mips64"; 246 case EF_MIPS_ARCH_32R2: 247 return "mips32r2"; 248 case EF_MIPS_ARCH_64R2: 249 return "mips64r2"; 250 case EF_MIPS_ARCH_32R6: 251 return "mips32r6"; 252 case EF_MIPS_ARCH_64R6: 253 return "mips64r6"; 254 default: 255 return "unknown arch"; 256 } 257 } 258 259 static std::string getFullArchName(uint32_t flags) { 260 StringRef arch = getArchName(flags); 261 StringRef mach = getMachName(flags); 262 if (mach.empty()) 263 return arch.str(); 264 return (arch + " (" + mach + ")").str(); 265 } 266 267 // There are (arguably too) many MIPS ISAs out there. Their relationships 268 // can be represented as a forest. If all input files have ISAs which 269 // reachable by repeated proceeding from the single child to the parent, 270 // these input files are compatible. In that case we need to return "highest" 271 // ISA. If there are incompatible input files, we show an error. 272 // For example, mips1 is a "parent" of mips2 and such files are compatible. 273 // Output file gets EF_MIPS_ARCH_2 flag. From the other side mips3 and mips32 274 // are incompatible because nor mips3 is a parent for misp32, nor mips32 275 // is a parent for mips3. 276 static uint32_t getArchFlags(ArrayRef<FileFlags> files) { 277 uint32_t ret = files[0].flags & (EF_MIPS_ARCH | EF_MIPS_MACH); 278 279 for (const FileFlags &f : files.slice(1)) { 280 uint32_t newFlags = f.flags & (EF_MIPS_ARCH | EF_MIPS_MACH); 281 282 // Check ISA compatibility. 283 if (isArchMatched(newFlags, ret)) 284 continue; 285 if (!isArchMatched(ret, newFlags)) { 286 error("incompatible target ISA:\n>>> " + toString(files[0].file) + ": " + 287 getFullArchName(ret) + "\n>>> " + toString(f.file) + ": " + 288 getFullArchName(newFlags)); 289 return 0; 290 } 291 ret = newFlags; 292 } 293 return ret; 294 } 295 296 template <class ELFT> uint32_t elf::calcMipsEFlags() { 297 std::vector<FileFlags> v; 298 for (InputFile *f : ctx.objectFiles) 299 v.push_back({f, cast<ObjFile<ELFT>>(f)->getObj().getHeader().e_flags}); 300 if (v.empty()) { 301 // If we don't have any input files, we'll have to rely on the information 302 // we can derive from emulation information, since this at least gets us 303 // ABI. 304 if (config->emulation.empty() || config->is64) 305 return 0; 306 return config->mipsN32Abi ? EF_MIPS_ABI2 : EF_MIPS_ABI_O32; 307 } 308 checkFlags(v); 309 return getMiscFlags(v) | getPicFlags(v) | getArchFlags(v); 310 } 311 312 static int compareMipsFpAbi(uint8_t fpA, uint8_t fpB) { 313 if (fpA == fpB) 314 return 0; 315 if (fpB == Mips::Val_GNU_MIPS_ABI_FP_ANY) 316 return 1; 317 if (fpB == Mips::Val_GNU_MIPS_ABI_FP_64A && 318 fpA == Mips::Val_GNU_MIPS_ABI_FP_64) 319 return 1; 320 if (fpB != Mips::Val_GNU_MIPS_ABI_FP_XX) 321 return -1; 322 if (fpA == Mips::Val_GNU_MIPS_ABI_FP_DOUBLE || 323 fpA == Mips::Val_GNU_MIPS_ABI_FP_64 || 324 fpA == Mips::Val_GNU_MIPS_ABI_FP_64A) 325 return 1; 326 return -1; 327 } 328 329 static StringRef getMipsFpAbiName(uint8_t fpAbi) { 330 switch (fpAbi) { 331 case Mips::Val_GNU_MIPS_ABI_FP_ANY: 332 return "any"; 333 case Mips::Val_GNU_MIPS_ABI_FP_DOUBLE: 334 return "-mdouble-float"; 335 case Mips::Val_GNU_MIPS_ABI_FP_SINGLE: 336 return "-msingle-float"; 337 case Mips::Val_GNU_MIPS_ABI_FP_SOFT: 338 return "-msoft-float"; 339 case Mips::Val_GNU_MIPS_ABI_FP_OLD_64: 340 return "-mgp32 -mfp64 (old)"; 341 case Mips::Val_GNU_MIPS_ABI_FP_XX: 342 return "-mfpxx"; 343 case Mips::Val_GNU_MIPS_ABI_FP_64: 344 return "-mgp32 -mfp64"; 345 case Mips::Val_GNU_MIPS_ABI_FP_64A: 346 return "-mgp32 -mfp64 -mno-odd-spreg"; 347 default: 348 return "unknown"; 349 } 350 } 351 352 uint8_t elf::getMipsFpAbiFlag(uint8_t oldFlag, uint8_t newFlag, 353 StringRef fileName) { 354 if (compareMipsFpAbi(newFlag, oldFlag) >= 0) 355 return newFlag; 356 if (compareMipsFpAbi(oldFlag, newFlag) < 0) 357 error(fileName + ": floating point ABI '" + getMipsFpAbiName(newFlag) + 358 "' is incompatible with target floating point ABI '" + 359 getMipsFpAbiName(oldFlag) + "'"); 360 return oldFlag; 361 } 362 363 template <class ELFT> static bool isN32Abi(const InputFile *f) { 364 if (auto *ef = dyn_cast<ELFFileBase>(f)) 365 return ef->template getObj<ELFT>().getHeader().e_flags & EF_MIPS_ABI2; 366 return false; 367 } 368 369 bool elf::isMipsN32Abi(const InputFile *f) { 370 switch (config->ekind) { 371 case ELF32LEKind: 372 return isN32Abi<ELF32LE>(f); 373 case ELF32BEKind: 374 return isN32Abi<ELF32BE>(f); 375 case ELF64LEKind: 376 return isN32Abi<ELF64LE>(f); 377 case ELF64BEKind: 378 return isN32Abi<ELF64BE>(f); 379 default: 380 llvm_unreachable("unknown Config->EKind"); 381 } 382 } 383 384 bool elf::isMicroMips() { return config->eflags & EF_MIPS_MICROMIPS; } 385 386 bool elf::isMipsR6() { 387 uint32_t arch = config->eflags & EF_MIPS_ARCH; 388 return arch == EF_MIPS_ARCH_32R6 || arch == EF_MIPS_ARCH_64R6; 389 } 390 391 template uint32_t elf::calcMipsEFlags<ELF32LE>(); 392 template uint32_t elf::calcMipsEFlags<ELF32BE>(); 393 template uint32_t elf::calcMipsEFlags<ELF64LE>(); 394 template uint32_t elf::calcMipsEFlags<ELF64BE>(); 395