AmdGcn intrinsics which return values in the constant address space.

This is separate because these intrinsics need to be used in the Geobacter patch and also "fixed" after the proper address spaces patch.

Author: DiamondLovesYou

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -7,6 +7,8 @@ use crate::type_of::LayoutLlvmExt;
 use crate::va_arg::emit_va_arg;
 use crate::value::Value;
 
+use libc::c_char;
+
 use rustc_codegen_ssa::base::{compare_simd_types, wants_msvc_seh};
 use rustc_codegen_ssa::common::span_invalid_monomorphization_error;
 use rustc_codegen_ssa::common::{IntPredicate, TypeKind};
@@ -22,6 +24,7 @@ use rustc_target::abi::{self, HasDataLayout, LayoutOf, Primitive};
 use rustc_target::spec::PanicStrategy;
 
 use std::cmp::Ordering;
+use std::ffi::CStr;
 use std::iter;
 
 fn get_simple_intrinsic(cx: &CodegenCx<'ll, '_>, name: Symbol) -> Option<&'ll Value> {
@@ -73,6 +76,9 @@ fn get_simple_intrinsic(cx: &CodegenCx<'ll, '_>, name: Symbol) -> Option<&'ll Va
     Some(cx.get_intrinsic(&llvm_name))
 }
 
+const EMPTY_C_STR: &CStr = unsafe { CStr::from_bytes_with_nul_unchecked(b"\0") };
+const UNNAMED: *const c_char = EMPTY_C_STR.as_ptr();
+
 impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
     fn codegen_intrinsic_call(
         &mut self,
@@ -303,6 +309,27 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                 }
             }
 
+            sym::amdgcn_dispatch_ptr => {
+                // This intrinsic returns a pointer in the const addr space
+                // which can't be encoded in source level Rust.
+
+                let f = self.cx().get_intrinsic("llvm.amdgcn.dispatch.ptr");
+                let val = self.call(f, &[], None);
+                // XXX Needs the proper address space patch
+                unsafe { llvm::LLVMBuildAddrSpaceCast(self.llbuilder, val,
+                                                      llret_ty, UNNAMED) }
+            }
+            sym::amdgcn_queue_ptr => {
+                // This intrinsic returns a pointer in the const addr space
+                // which can't be encoded in source level Rust.
+
+                let f = self.cx().get_intrinsic("llvm.amdgcn.queue.ptr");
+                let val = self.call(f, &[], None);
+                // XXX Needs the proper address space patch
+                unsafe { llvm::LLVMBuildAddrSpaceCast(self.llbuilder, val,
+                                                      llret_ty, UNNAMED) }
+            }
+
             _ => bug!("unknown intrinsic '{}'", name),
         };
 

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1475,6 +1475,12 @@ extern "C" {
         DestTy: &'a Type,
         Name: *const c_char,
     ) -> &'a Value;
+    pub fn LLVMBuildAddrSpaceCast(
+        B: &Builder<'a>,
+        Val: &'a Value,
+        DestTy: &'a Type,
+        Name: *const c_char,
+    ) -> &'a Value;
     pub fn LLVMRustBuildIntCast(
         B: &Builder<'a>,
         Val: &'a Value,

compiler/rustc_span/src/symbol.rs

@@ -250,6 +250,8 @@ symbols! {
         allow_internal_unstable_backcompat_hack,
         allowed,
         always,
+        amdgcn_dispatch_ptr,
+        amdgcn_queue_ptr,
         and,
         and_then,
         any,

compiler/rustc_typeck/src/check/intrinsic.rs

@@ -369,6 +369,13 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
 
             sym::nontemporal_store => (1, vec![tcx.mk_mut_ptr(param(0)), param(0)], tcx.mk_unit()),
 
+            sym::amdgcn_dispatch_ptr => {
+                (0, vec![], tcx.mk_imm_ptr(tcx.types.u8))
+            }
+            sym::amdgcn_queue_ptr => {
+                (0, vec![], tcx.mk_imm_ptr(tcx.types.u8))
+            }
+
             other => {
                 tcx.sess.emit_err(UnrecognizedIntrinsicFunction { span: it.span, name: other });
                 return;