summaryrefslogtreecommitdiffstats
path: root/compiler/rustc_llvm
diff options
context:
space:
mode:
Diffstat (limited to 'compiler/rustc_llvm')
-rw-r--r--compiler/rustc_llvm/llvm-wrapper/ArchiveWrapper.cpp3
-rw-r--r--compiler/rustc_llvm/llvm-wrapper/CoverageMappingWrapper.cpp109
-rw-r--r--compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp134
3 files changed, 153 insertions, 93 deletions
diff --git a/compiler/rustc_llvm/llvm-wrapper/ArchiveWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/ArchiveWrapper.cpp
index 448a1f62f..35d6b9ed7 100644
--- a/compiler/rustc_llvm/llvm-wrapper/ArchiveWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/ArchiveWrapper.cpp
@@ -39,6 +39,7 @@ enum class LLVMRustArchiveKind {
BSD,
DARWIN,
COFF,
+ AIX_BIG,
};
static Archive::Kind fromRust(LLVMRustArchiveKind Kind) {
@@ -51,6 +52,8 @@ static Archive::Kind fromRust(LLVMRustArchiveKind Kind) {
return Archive::K_DARWIN;
case LLVMRustArchiveKind::COFF:
return Archive::K_COFF;
+ case LLVMRustArchiveKind::AIX_BIG:
+ return Archive::K_AIXBIG;
default:
report_fatal_error("Bad ArchiveKind.");
}
diff --git a/compiler/rustc_llvm/llvm-wrapper/CoverageMappingWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/CoverageMappingWrapper.cpp
index 03e6d2149..87906dee4 100644
--- a/compiler/rustc_llvm/llvm-wrapper/CoverageMappingWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/CoverageMappingWrapper.cpp
@@ -8,18 +8,100 @@
using namespace llvm;
+// FFI equivalent of enum `llvm::coverage::Counter::CounterKind`
+// https://github.com/rust-lang/llvm-project/blob/ea6fa9c2/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L97-L99
+enum class LLVMRustCounterKind {
+ Zero = 0,
+ CounterValueReference = 1,
+ Expression = 2,
+};
+
+// FFI equivalent of struct `llvm::coverage::Counter`
+// https://github.com/rust-lang/llvm-project/blob/ea6fa9c2/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L94-L149
+struct LLVMRustCounter {
+ LLVMRustCounterKind CounterKind;
+ uint32_t ID;
+};
+
+static coverage::Counter fromRust(LLVMRustCounter Counter) {
+ switch (Counter.CounterKind) {
+ case LLVMRustCounterKind::Zero:
+ return coverage::Counter::getZero();
+ case LLVMRustCounterKind::CounterValueReference:
+ return coverage::Counter::getCounter(Counter.ID);
+ case LLVMRustCounterKind::Expression:
+ return coverage::Counter::getExpression(Counter.ID);
+ }
+ report_fatal_error("Bad LLVMRustCounterKind!");
+}
+
+// FFI equivalent of enum `llvm::coverage::CounterMappingRegion::RegionKind`
+// https://github.com/rust-lang/llvm-project/blob/ea6fa9c2/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L213-L234
+enum class LLVMRustCounterMappingRegionKind {
+ CodeRegion = 0,
+ ExpansionRegion = 1,
+ SkippedRegion = 2,
+ GapRegion = 3,
+ BranchRegion = 4,
+};
+
+static coverage::CounterMappingRegion::RegionKind
+fromRust(LLVMRustCounterMappingRegionKind Kind) {
+ switch (Kind) {
+ case LLVMRustCounterMappingRegionKind::CodeRegion:
+ return coverage::CounterMappingRegion::CodeRegion;
+ case LLVMRustCounterMappingRegionKind::ExpansionRegion:
+ return coverage::CounterMappingRegion::ExpansionRegion;
+ case LLVMRustCounterMappingRegionKind::SkippedRegion:
+ return coverage::CounterMappingRegion::SkippedRegion;
+ case LLVMRustCounterMappingRegionKind::GapRegion:
+ return coverage::CounterMappingRegion::GapRegion;
+ case LLVMRustCounterMappingRegionKind::BranchRegion:
+ return coverage::CounterMappingRegion::BranchRegion;
+ }
+ report_fatal_error("Bad LLVMRustCounterMappingRegionKind!");
+}
+
+// FFI equivalent of struct `llvm::coverage::CounterMappingRegion`
+// https://github.com/rust-lang/llvm-project/blob/ea6fa9c2/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L211-L304
struct LLVMRustCounterMappingRegion {
- coverage::Counter Count;
- coverage::Counter FalseCount;
+ LLVMRustCounter Count;
+ LLVMRustCounter FalseCount;
uint32_t FileID;
uint32_t ExpandedFileID;
uint32_t LineStart;
uint32_t ColumnStart;
uint32_t LineEnd;
uint32_t ColumnEnd;
- coverage::CounterMappingRegion::RegionKind Kind;
+ LLVMRustCounterMappingRegionKind Kind;
+};
+
+// FFI equivalent of enum `llvm::coverage::CounterExpression::ExprKind`
+// https://github.com/rust-lang/llvm-project/blob/ea6fa9c2/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L154
+enum class LLVMRustCounterExprKind {
+ Subtract = 0,
+ Add = 1,
};
+// FFI equivalent of struct `llvm::coverage::CounterExpression`
+// https://github.com/rust-lang/llvm-project/blob/ea6fa9c2/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L151-L160
+struct LLVMRustCounterExpression {
+ LLVMRustCounterExprKind Kind;
+ LLVMRustCounter LHS;
+ LLVMRustCounter RHS;
+};
+
+static coverage::CounterExpression::ExprKind
+fromRust(LLVMRustCounterExprKind Kind) {
+ switch (Kind) {
+ case LLVMRustCounterExprKind::Subtract:
+ return coverage::CounterExpression::Subtract;
+ case LLVMRustCounterExprKind::Add:
+ return coverage::CounterExpression::Add;
+ }
+ report_fatal_error("Bad LLVMRustCounterExprKind!");
+}
+
extern "C" void LLVMRustCoverageWriteFilenamesSectionToBuffer(
const char* const Filenames[],
size_t FilenamesLen,
@@ -37,9 +119,9 @@ extern "C" void LLVMRustCoverageWriteFilenamesSectionToBuffer(
extern "C" void LLVMRustCoverageWriteMappingToBuffer(
const unsigned *VirtualFileMappingIDs,
unsigned NumVirtualFileMappingIDs,
- const coverage::CounterExpression *Expressions,
+ const LLVMRustCounterExpression *RustExpressions,
unsigned NumExpressions,
- LLVMRustCounterMappingRegion *RustMappingRegions,
+ const LLVMRustCounterMappingRegion *RustMappingRegions,
unsigned NumMappingRegions,
RustStringRef BufferOut) {
// Convert from FFI representation to LLVM representation.
@@ -48,13 +130,24 @@ extern "C" void LLVMRustCoverageWriteMappingToBuffer(
for (const auto &Region : ArrayRef<LLVMRustCounterMappingRegion>(
RustMappingRegions, NumMappingRegions)) {
MappingRegions.emplace_back(
- Region.Count, Region.FalseCount, Region.FileID, Region.ExpandedFileID,
+ fromRust(Region.Count), fromRust(Region.FalseCount),
+ Region.FileID, Region.ExpandedFileID,
Region.LineStart, Region.ColumnStart, Region.LineEnd, Region.ColumnEnd,
- Region.Kind);
+ fromRust(Region.Kind));
}
+
+ std::vector<coverage::CounterExpression> Expressions;
+ Expressions.reserve(NumExpressions);
+ for (const auto &Expression :
+ ArrayRef<LLVMRustCounterExpression>(RustExpressions, NumExpressions)) {
+ Expressions.emplace_back(fromRust(Expression.Kind),
+ fromRust(Expression.LHS),
+ fromRust(Expression.RHS));
+ }
+
auto CoverageMappingWriter = coverage::CoverageMappingWriter(
ArrayRef<unsigned>(VirtualFileMappingIDs, NumVirtualFileMappingIDs),
- ArrayRef<coverage::CounterExpression>(Expressions, NumExpressions),
+ Expressions,
MappingRegions);
RawRustStringOstream OS(BufferOut);
CoverageMappingWriter.write(OS);
diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index 08e38b0c9..c43a02724 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -297,7 +297,6 @@ static Reloc::Model fromRust(LLVMRustRelocModel RustReloc) {
report_fatal_error("Bad RelocModel.");
}
-#ifdef LLVM_RUSTLLVM
/// getLongestEntryLength - Return the length of the longest entry in the table.
template<typename KV>
static size_t getLongestEntryLength(ArrayRef<KV> Table) {
@@ -307,54 +306,68 @@ static size_t getLongestEntryLength(ArrayRef<KV> Table) {
return MaxLen;
}
-extern "C" void LLVMRustPrintTargetCPUs(LLVMTargetMachineRef TM) {
+extern "C" void LLVMRustPrintTargetCPUs(LLVMTargetMachineRef TM, const char* TargetCPU) {
const TargetMachine *Target = unwrap(TM);
const MCSubtargetInfo *MCInfo = Target->getMCSubtargetInfo();
- const Triple::ArchType HostArch = Triple(sys::getProcessTriple()).getArch();
+ const Triple::ArchType HostArch = Triple(sys::getDefaultTargetTriple()).getArch();
const Triple::ArchType TargetArch = Target->getTargetTriple().getArch();
+
+#if LLVM_VERSION_GE(17, 0)
+ const ArrayRef<SubtargetSubTypeKV> CPUTable = MCInfo->getAllProcessorDescriptions();
+#elif defined(LLVM_RUSTLLVM)
const ArrayRef<SubtargetSubTypeKV> CPUTable = MCInfo->getCPUTable();
+#else
+ printf("Full target CPU help is not supported by this LLVM version.\n\n");
+ SubtargetSubTypeKV TargetCPUKV = { TargetCPU, {{}}, {{}} };
+ const ArrayRef<SubtargetSubTypeKV> CPUTable = TargetCPUKV;
+#endif
unsigned MaxCPULen = getLongestEntryLength(CPUTable);
printf("Available CPUs for this target:\n");
+ // Don't print the "native" entry when the user specifies --target with a
+ // different arch since that could be wrong or misleading.
if (HostArch == TargetArch) {
+ MaxCPULen = std::max(MaxCPULen, (unsigned) std::strlen("native"));
const StringRef HostCPU = sys::getHostCPUName();
printf(" %-*s - Select the CPU of the current host (currently %.*s).\n",
MaxCPULen, "native", (int)HostCPU.size(), HostCPU.data());
}
- for (auto &CPU : CPUTable)
- printf(" %-*s\n", MaxCPULen, CPU.Key);
- printf("\n");
+ for (auto &CPU : CPUTable) {
+ // Compare cpu against current target to label the default
+ if (strcmp(CPU.Key, TargetCPU) == 0) {
+ printf(" %-*s - This is the default target CPU"
+ " for the current build target (currently %s).",
+ MaxCPULen, CPU.Key, Target->getTargetTriple().str().c_str());
+ }
+ else {
+ printf(" %-*s", MaxCPULen, CPU.Key);
+ }
+ printf("\n");
+ }
}
extern "C" size_t LLVMRustGetTargetFeaturesCount(LLVMTargetMachineRef TM) {
+#ifdef LLVM_RUSTLLVM
const TargetMachine *Target = unwrap(TM);
const MCSubtargetInfo *MCInfo = Target->getMCSubtargetInfo();
const ArrayRef<SubtargetFeatureKV> FeatTable = MCInfo->getFeatureTable();
return FeatTable.size();
+#else
+ return 0;
+#endif
}
extern "C" void LLVMRustGetTargetFeature(LLVMTargetMachineRef TM, size_t Index,
const char** Feature, const char** Desc) {
+#ifdef LLVM_RUSTLLVM
const TargetMachine *Target = unwrap(TM);
const MCSubtargetInfo *MCInfo = Target->getMCSubtargetInfo();
const ArrayRef<SubtargetFeatureKV> FeatTable = MCInfo->getFeatureTable();
const SubtargetFeatureKV Feat = FeatTable[Index];
*Feature = Feat.Key;
*Desc = Feat.Desc;
-}
-
-#else
-
-extern "C" void LLVMRustPrintTargetCPUs(LLVMTargetMachineRef) {
- printf("Target CPU help is not supported by this LLVM version.\n\n");
-}
-
-extern "C" size_t LLVMRustGetTargetFeaturesCount(LLVMTargetMachineRef) {
- return 0;
-}
-
-extern "C" void LLVMRustGetTargetFeature(LLVMTargetMachineRef, const char**, const char**) {}
#endif
+}
extern "C" const char* LLVMRustGetHostCPUName(size_t *len) {
StringRef Name = sys::getHostCPUName();
@@ -408,10 +421,15 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
}
Options.RelaxELFRelocations = RelaxELFRelocations;
Options.UseInitArray = UseInitArray;
+
+#if LLVM_VERSION_LT(17, 0)
if (ForceEmulatedTls) {
Options.ExplicitEmulatedTLS = true;
Options.EmulatedTLS = true;
}
+#else
+ Options.EmulatedTLS = ForceEmulatedTls || Trip.hasDefaultEmulatedTLS();
+#endif
if (TrapUnreachable) {
// Tell LLVM to codegen `unreachable` into an explicit trap instruction.
@@ -523,14 +541,14 @@ extern "C" typedef void (*LLVMRustSelfProfileBeforePassCallback)(void*, // LlvmS
extern "C" typedef void (*LLVMRustSelfProfileAfterPassCallback)(void*); // LlvmSelfProfiler
std::string LLVMRustwrappedIrGetName(const llvm::Any &WrappedIr) {
- if (any_isa<const Module *>(WrappedIr))
- return any_cast<const Module *>(WrappedIr)->getName().str();
- if (any_isa<const Function *>(WrappedIr))
- return any_cast<const Function *>(WrappedIr)->getName().str();
- if (any_isa<const Loop *>(WrappedIr))
- return any_cast<const Loop *>(WrappedIr)->getName().str();
- if (any_isa<const LazyCallGraph::SCC *>(WrappedIr))
- return any_cast<const LazyCallGraph::SCC *>(WrappedIr)->getName();
+ if (const auto *Cast = any_cast<const Module *>(&WrappedIr))
+ return (*Cast)->getName().str();
+ if (const auto *Cast = any_cast<const Function *>(&WrappedIr))
+ return (*Cast)->getName().str();
+ if (const auto *Cast = any_cast<const Loop *>(&WrappedIr))
+ return (*Cast)->getName().str();
+ if (const auto *Cast = any_cast<const LazyCallGraph::SCC *>(&WrappedIr))
+ return (*Cast)->getName();
return "<UNKNOWN>";
}
@@ -727,6 +745,9 @@ LLVMRustOptimize(
if (InstrProfileOutput) {
Options.InstrProfileOutput = InstrProfileOutput;
}
+ // cargo run tests in multhreading mode by default
+ // so use atomics for coverage counters
+ Options.Atomic = true;
MPM.addPass(InstrProfiling(Options, false));
}
);
@@ -811,7 +832,7 @@ LLVMRustOptimize(
ModulePassManager MPM;
bool NeedThinLTOBufferPasses = UseThinLTOBuffers;
if (!NoPrepopulatePasses) {
- // The pre-link pipelines don't support O0 and require using budilO0DefaultPipeline() instead.
+ // The pre-link pipelines don't support O0 and require using buildO0DefaultPipeline() instead.
// At the same time, the LTO pipelines do support O0 and using them is required.
bool IsLTO = OptStage == LLVMRustOptStage::ThinLTO || OptStage == LLVMRustOptStage::FatLTO;
if (OptLevel == OptimizationLevel::O0 && !IsLTO) {
@@ -1442,63 +1463,6 @@ LLVMRustGetBitcodeSliceFromObjectData(const char *data,
return BitcodeOrError->getBufferStart();
}
-// Rewrite all `DICompileUnit` pointers to the `DICompileUnit` specified. See
-// the comment in `back/lto.rs` for why this exists.
-extern "C" void
-LLVMRustThinLTOGetDICompileUnit(LLVMModuleRef Mod,
- DICompileUnit **A,
- DICompileUnit **B) {
- Module *M = unwrap(Mod);
- DICompileUnit **Cur = A;
- DICompileUnit **Next = B;
- for (DICompileUnit *CU : M->debug_compile_units()) {
- *Cur = CU;
- Cur = Next;
- Next = nullptr;
- if (Cur == nullptr)
- break;
- }
-}
-
-// Rewrite all `DICompileUnit` pointers to the `DICompileUnit` specified. See
-// the comment in `back/lto.rs` for why this exists.
-extern "C" void
-LLVMRustThinLTOPatchDICompileUnit(LLVMModuleRef Mod, DICompileUnit *Unit) {
- Module *M = unwrap(Mod);
-
- // If the original source module didn't have a `DICompileUnit` then try to
- // merge all the existing compile units. If there aren't actually any though
- // then there's not much for us to do so return.
- if (Unit == nullptr) {
- for (DICompileUnit *CU : M->debug_compile_units()) {
- Unit = CU;
- break;
- }
- if (Unit == nullptr)
- return;
- }
-
- // Use LLVM's built-in `DebugInfoFinder` to find a bunch of debuginfo and
- // process it recursively. Note that we used to specifically iterate over
- // instructions to ensure we feed everything into it, but `processModule`
- // started doing this the same way in LLVM 7 (commit d769eb36ab2b8).
- DebugInfoFinder Finder;
- Finder.processModule(*M);
-
- // After we've found all our debuginfo, rewrite all subprograms to point to
- // the same `DICompileUnit`.
- for (auto &F : Finder.subprograms()) {
- F->replaceUnit(Unit);
- }
-
- // Erase any other references to other `DICompileUnit` instances, the verifier
- // will later ensure that we don't actually have any other stale references to
- // worry about.
- auto *MD = M->getNamedMetadata("llvm.dbg.cu");
- MD->clearOperands();
- MD->addOperand(Unit);
-}
-
// Computes the LTO cache key for the provided 'ModId' in the given 'Data',
// storing the result in 'KeyOut'.
// Currently, this cache key is a SHA-1 hash of anything that could affect