user/rust: Add LLVM 8 compatibility patch, and use LLVM 8

1 files changed, 310 insertions, 0 deletions

diff --git a/user/rust/0050-LLVM-8.0-compatibility.patch b/user/rust/0050-LLVM-8.0-compatibility.patch
new file mode 100644
index 000000000..a8bffb2b9
--- /dev/null
+++ b/user/rust/0050-LLVM-8.0-compatibility.patch
@@ -0,0 +1,310 @@
+From 78ff5598497c95a696ca669f88a93d127aa24c8d Mon Sep 17 00:00:00 2001
+From: Josh Stone <jistone@redhat.com>
+Date: Wed, 16 Jan 2019 09:59:03 -0800
+Subject: [PATCH 08/15] LLVM 8.0 compatibility
+
+Backported from commit df0466d upstream.
+---
+ src/librustc_codegen_llvm/debuginfo/mod.rs | 15 ++--
+ src/librustc_codegen_llvm/llvm/ffi.rs      | 22 +++--
+ src/rustllvm/PassWrapper.cpp               |  7 +-
+ src/rustllvm/RustWrapper.cpp               | 93 ++++++++++++++++++++--
+ src/test/codegen/enum-debug-clike.rs       |  5 +-
+ 5 files changed, 123 insertions(+), 19 deletions(-)
+
+diff --git a/src/librustc_codegen_llvm/debuginfo/mod.rs b/src/librustc_codegen_llvm/debuginfo/mod.rs
+index 2eab626ae8..7aca63caa4 100644
+--- a/src/librustc_codegen_llvm/debuginfo/mod.rs
++++ b/src/librustc_codegen_llvm/debuginfo/mod.rs
+@@ -12,7 +12,7 @@ use self::source_loc::InternalDebugLocation::{self, UnknownLocation};
+ 
+ use llvm;
+ use llvm::debuginfo::{DIFile, DIType, DIScope, DIBuilder, DISubprogram, DIArray, DIFlags,
+-    DILexicalBlock};
++    DISPFlags, DILexicalBlock};
+ use rustc::hir::CodegenFnAttrFlags;
+ use rustc::hir::def_id::{DefId, CrateNum};
+ use rustc::ty::subst::{Substs, UnpackedKind};
+@@ -283,7 +283,6 @@ impl DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
+         let linkage_name = mangled_name_of_instance(self, instance);
+ 
+         let scope_line = span_start(self, span).line;
+-        let is_local_to_unit = is_node_local_to_unit(self, def_id);
+ 
+         let function_name = CString::new(name).unwrap();
+         let linkage_name = SmallCStr::new(&linkage_name.as_str());
+@@ -301,6 +300,14 @@ impl DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
+             flags |= DIFlags::FlagNoReturn;
+         }
+ 
++        let mut spflags = DISPFlags::SPFlagDefinition;
++        if is_node_local_to_unit(self, def_id) {
++            spflags |= DISPFlags::SPFlagLocalToUnit;
++        }
++        if self.sess().opts.optimize != config::OptLevel::No {
++            spflags |= DISPFlags::SPFlagOptimized;
++        }
++
+         let fn_metadata = unsafe {
+             llvm::LLVMRustDIBuilderCreateFunction(
+                 DIB(self),
+@@ -310,11 +317,9 @@ impl DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
+                 file_metadata,
+                 loc.line as c_uint,
+                 function_type_metadata,
+-                is_local_to_unit,
+-                true,
+                 scope_line as c_uint,
+                 flags,
+-                self.sess().opts.optimize != config::OptLevel::No,
++                spflags,
+                 llfn,
+                 template_parameters,
+                 None)
+diff --git a/src/librustc_codegen_llvm/llvm/ffi.rs b/src/librustc_codegen_llvm/llvm/ffi.rs
+index 11e34f600c..853c1ff004 100644
+--- a/src/librustc_codegen_llvm/llvm/ffi.rs
++++ b/src/librustc_codegen_llvm/llvm/ffi.rs
+@@ -2,7 +2,7 @@ use super::debuginfo::{
+     DIBuilder, DIDescriptor, DIFile, DILexicalBlock, DISubprogram, DIType,
+     DIBasicType, DIDerivedType, DICompositeType, DIScope, DIVariable,
+     DIGlobalVariableExpression, DIArray, DISubrange, DITemplateTypeParameter, DIEnumerator,
+-    DINameSpace, DIFlags,
++    DINameSpace, DIFlags, DISPFlags,
+ };
+ 
+ use libc::{c_uint, c_int, size_t, c_char};
+@@ -591,6 +591,20 @@ pub mod debuginfo {
+             const FlagMainSubprogram      = (1 << 21);
+         }
+     }
++
++    // These values **must** match with LLVMRustDISPFlags!!
++    bitflags! {
++        #[repr(C)]
++        #[derive(Default)]
++        pub struct DISPFlags: ::libc::uint32_t {
++            const SPFlagZero              = 0;
++            const SPFlagVirtual           = 1;
++            const SPFlagPureVirtual       = 2;
++            const SPFlagLocalToUnit       = (1 << 2);
++            const SPFlagDefinition        = (1 << 3);
++            const SPFlagOptimized         = (1 << 4);
++        }
++    }
+ }
+ 
+ extern { pub type ModuleBuffer; }
+@@ -1387,11 +1401,9 @@ extern "C" {
+                                            File: &'a DIFile,
+                                            LineNo: c_uint,
+                                            Ty: &'a DIType,
+-                                           isLocalToUnit: bool,
+-                                           isDefinition: bool,
+                                            ScopeLine: c_uint,
+                                            Flags: DIFlags,
+-                                           isOptimized: bool,
++                                           SPFlags: DISPFlags,
+                                            Fn: &'a Value,
+                                            TParam: &'a DIArray,
+                                            Decl: Option<&'a DIDescriptor>)
+@@ -1529,7 +1541,7 @@ extern "C" {
+                                                   AlignInBits: u32,
+                                                   Elements: &'a DIArray,
+                                                   ClassType: &'a DIType,
+-                                                  IsFixed: bool)
++                                                  IsScoped: bool)
+                                                   -> &'a DIType;
+ 
+     pub fn LLVMRustDIBuilderCreateUnionType(Builder: &DIBuilder<'a>,
+diff --git a/src/rustllvm/PassWrapper.cpp b/src/rustllvm/PassWrapper.cpp
+index df7a81643b..18d277be21 100644
+--- a/src/rustllvm/PassWrapper.cpp
++++ b/src/rustllvm/PassWrapper.cpp
+@@ -789,7 +789,7 @@ struct LLVMRustThinLTOData {
+   StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries;
+ 
+ #if LLVM_VERSION_GE(7, 0)
+-  LLVMRustThinLTOData() : Index(/* isPerformingAnalysis = */ false) {}
++  LLVMRustThinLTOData() : Index(/* HaveGVs = */ false) {}
+ #endif
+ };
+ 
+@@ -865,7 +865,12 @@ LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules,
+   auto deadIsPrevailing = [&](GlobalValue::GUID G) {
+     return PrevailingType::Unknown;
+   };
++#if LLVM_VERSION_GE(8, 0)
++  computeDeadSymbolsWithConstProp(Ret->Index, Ret->GUIDPreservedSymbols,
++                                  deadIsPrevailing, /* ImportEnabled = */ true);
++#else
+   computeDeadSymbols(Ret->Index, Ret->GUIDPreservedSymbols, deadIsPrevailing);
++#endif
+ #else
+   computeDeadSymbols(Ret->Index, Ret->GUIDPreservedSymbols);
+ #endif
+diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp
+index 9d3e6f93b0..7905e9f0f2 100644
+--- a/src/rustllvm/RustWrapper.cpp
++++ b/src/rustllvm/RustWrapper.cpp
+@@ -294,7 +294,7 @@ extern "C" void LLVMRustSetHasUnsafeAlgebra(LLVMValueRef V) {
+ extern "C" LLVMValueRef
+ LLVMRustBuildAtomicLoad(LLVMBuilderRef B, LLVMValueRef Source, const char *Name,
+                         LLVMAtomicOrdering Order) {
+-  LoadInst *LI = new LoadInst(unwrap(Source), 0);
++  LoadInst *LI = new LoadInst(unwrap(Source));
+   LI->setAtomic(fromRust(Order));
+   return wrap(unwrap(B)->Insert(LI, Name));
+ }
+@@ -511,6 +511,71 @@ static DINode::DIFlags fromRust(LLVMRustDIFlags Flags) {
+   return Result;
+ }
+ 
++// These values **must** match debuginfo::DISPFlags! They also *happen*
++// to match LLVM, but that isn't required as we do giant sets of
++// matching below. The value shouldn't be directly passed to LLVM.
++enum class LLVMRustDISPFlags : uint32_t {
++  SPFlagZero = 0,
++  SPFlagVirtual = 1,
++  SPFlagPureVirtual = 2,
++  SPFlagLocalToUnit = (1 << 2),
++  SPFlagDefinition = (1 << 3),
++  SPFlagOptimized = (1 << 4),
++  // Do not add values that are not supported by the minimum LLVM
++  // version we support! see llvm/include/llvm/IR/DebugInfoFlags.def
++  // (In LLVM < 8, createFunction supported these as separate bool arguments.)
++};
++
++inline LLVMRustDISPFlags operator&(LLVMRustDISPFlags A, LLVMRustDISPFlags B) {
++  return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(A) &
++                                      static_cast<uint32_t>(B));
++}
++
++inline LLVMRustDISPFlags operator|(LLVMRustDISPFlags A, LLVMRustDISPFlags B) {
++  return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(A) |
++                                      static_cast<uint32_t>(B));
++}
++
++inline LLVMRustDISPFlags &operator|=(LLVMRustDISPFlags &A, LLVMRustDISPFlags B) {
++  return A = A | B;
++}
++
++inline bool isSet(LLVMRustDISPFlags F) { return F != LLVMRustDISPFlags::SPFlagZero; }
++
++inline LLVMRustDISPFlags virtuality(LLVMRustDISPFlags F) {
++  return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(F) & 0x3);
++}
++
++#if LLVM_VERSION_GE(8, 0)
++static DISubprogram::DISPFlags fromRust(LLVMRustDISPFlags SPFlags) {
++  DISubprogram::DISPFlags Result = DISubprogram::DISPFlags::SPFlagZero;
++
++  switch (virtuality(SPFlags)) {
++  case LLVMRustDISPFlags::SPFlagVirtual:
++    Result |= DISubprogram::DISPFlags::SPFlagVirtual;
++    break;
++  case LLVMRustDISPFlags::SPFlagPureVirtual:
++    Result |= DISubprogram::DISPFlags::SPFlagPureVirtual;
++    break;
++  default:
++    // The rest are handled below
++    break;
++  }
++
++  if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagLocalToUnit)) {
++    Result |= DISubprogram::DISPFlags::SPFlagLocalToUnit;
++  }
++  if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagDefinition)) {
++    Result |= DISubprogram::DISPFlags::SPFlagDefinition;
++  }
++  if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagOptimized)) {
++    Result |= DISubprogram::DISPFlags::SPFlagOptimized;
++  }
++
++  return Result;
++}
++#endif
++
+ extern "C" uint32_t LLVMRustDebugMetadataVersion() {
+   return DEBUG_METADATA_VERSION;
+ }
+@@ -575,16 +640,26 @@ LLVMRustDIBuilderCreateSubroutineType(LLVMRustDIBuilderRef Builder,
+ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateFunction(
+     LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+     const char *LinkageName, LLVMMetadataRef File, unsigned LineNo,
+-    LLVMMetadataRef Ty, bool IsLocalToUnit, bool IsDefinition,
+-    unsigned ScopeLine, LLVMRustDIFlags Flags, bool IsOptimized,
+-    LLVMValueRef Fn, LLVMMetadataRef TParam, LLVMMetadataRef Decl) {
++    LLVMMetadataRef Ty, unsigned ScopeLine, LLVMRustDIFlags Flags,
++    LLVMRustDISPFlags SPFlags, LLVMValueRef Fn, LLVMMetadataRef TParam,
++    LLVMMetadataRef Decl) {
+   DITemplateParameterArray TParams =
+       DITemplateParameterArray(unwrap<MDTuple>(TParam));
++#if LLVM_VERSION_GE(8, 0)
++  DISubprogram *Sub = Builder->createFunction(
++      unwrapDI<DIScope>(Scope), Name, LinkageName, unwrapDI<DIFile>(File),
++      LineNo, unwrapDI<DISubroutineType>(Ty), ScopeLine, fromRust(Flags),
++      fromRust(SPFlags), TParams, unwrapDIPtr<DISubprogram>(Decl));
++#else
++  bool IsLocalToUnit = isSet(SPFlags & LLVMRustDISPFlags::SPFlagLocalToUnit);
++  bool IsDefinition = isSet(SPFlags & LLVMRustDISPFlags::SPFlagDefinition);
++  bool IsOptimized = isSet(SPFlags & LLVMRustDISPFlags::SPFlagOptimized);
+   DISubprogram *Sub = Builder->createFunction(
+       unwrapDI<DIScope>(Scope), Name, LinkageName, unwrapDI<DIFile>(File),
+       LineNo, unwrapDI<DISubroutineType>(Ty), IsLocalToUnit, IsDefinition,
+       ScopeLine, fromRust(Flags), IsOptimized, TParams,
+       unwrapDIPtr<DISubprogram>(Decl));
++#endif
+   unwrap<Function>(Fn)->setSubprogram(Sub);
+   return wrap(Sub);
+ }
+@@ -773,14 +848,14 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateEnumerationType(
+     LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+     LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
+     uint32_t AlignInBits, LLVMMetadataRef Elements,
+-    LLVMMetadataRef ClassTy, bool IsFixed) {
++    LLVMMetadataRef ClassTy, bool IsScoped) {
+ #if LLVM_VERSION_GE(7, 0)
+   return wrap(Builder->createEnumerationType(
+       unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber,
+       SizeInBits, AlignInBits, DINodeArray(unwrapDI<MDTuple>(Elements)),
+-      unwrapDI<DIType>(ClassTy), "", IsFixed));
++      unwrapDI<DIType>(ClassTy), "", IsScoped));
+ #else
+-  // Ignore IsFixed on older LLVM.
++  // Ignore IsScoped on older LLVM.
+   return wrap(Builder->createEnumerationType(
+       unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber,
+       SizeInBits, AlignInBits, DINodeArray(unwrapDI<MDTuple>(Elements)),
+@@ -920,7 +995,11 @@ extern "C" void LLVMRustUnpackOptimizationDiagnostic(
+   if (loc.isValid()) {
+     *Line = loc.getLine();
+     *Column = loc.getColumn();
++#if LLVM_VERSION_GE(8, 0)
++    FilenameOS << loc.getAbsolutePath();
++#else
+     FilenameOS << loc.getFilename();
++#endif
+   }
+ 
+   RawRustStringOstream MessageOS(MessageOut);
+diff --git a/src/test/codegen/enum-debug-clike.rs b/src/test/codegen/enum-debug-clike.rs
+index 98f07505f7..62cfef5a84 100644
+--- a/src/test/codegen/enum-debug-clike.rs
++++ b/src/test/codegen/enum-debug-clike.rs
+@@ -8,8 +8,11 @@
+ 
+ // compile-flags: -g -C no-prepopulate-passes
+ 
++// DIFlagFixedEnum was deprecated in 8.0, renamed to DIFlagEnumClass.
++// We match either for compatibility.
++
+ // CHECK-LABEL: @main
+-// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_enumeration_type,{{.*}}name: "E",{{.*}}flags: DIFlagFixedEnum,{{.*}}
++// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_enumeration_type,{{.*}}name: "E",{{.*}}flags: {{(DIFlagEnumClass|DIFlagFixedEnum)}},{{.*}}
+ // CHECK: {{.*}}DIEnumerator{{.*}}name: "A",{{.*}}value: {{[0-9].*}}
+ // CHECK: {{.*}}DIEnumerator{{.*}}name: "B",{{.*}}value: {{[0-9].*}}
+ // CHECK: {{.*}}DIEnumerator{{.*}}name: "C",{{.*}}value: {{[0-9].*}}
+-- 
+2.19.2
+