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

src/librustc_codegen_llvm/intrinsic.rs

@@ -8,6 +8,8 @@ use crate::type_of::LayoutLlvmExt;
 use crate::va_arg::emit_va_arg;
 use crate::value::Value;
 
+use libc::c_char;
+
 use rustc_ast::ast;
 use rustc_codegen_ssa::base::{compare_simd_types, to_immediate, wants_msvc_seh};
 use rustc_codegen_ssa::common::span_invalid_monomorphization_error;
@@ -25,6 +27,7 @@ use rustc_span::Span;
 use rustc_target::abi::{self, HasDataLayout, LayoutOf, Primitive};
 
 use std::cmp::Ordering;
+use std::ffi::CStr;
 use std::{i128, iter, u128};
 
 fn get_simple_intrinsic(cx: &CodegenCx<'ll, '_>, name: &str) -> Option<&'ll Value> {
@@ -78,6 +81,9 @@ fn get_simple_intrinsic(cx: &CodegenCx<'ll, '_>, name: &str) -> Option<&'ll Valu
     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,
@@ -747,6 +753,26 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                 // this is where the signed magic happens (notice the `s` in `exactsdiv`)
                 self.exactsdiv(d, pointee_size)
             }
+            "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) }
+            }
+            "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),
         };

src/librustc_codegen_llvm/llvm/ffi.rs

@@ -1323,6 +1323,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,

src/librustc_typeck/check/intrinsic.rs

@@ -338,6 +338,12 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
                 // so it's not trivial to check this
                 return;
             }
+            "amdgcn_dispatch_ptr" => {
+                (0, vec![], tcx.mk_imm_ptr(tcx.types.u8))
+            }
+            "amdgcn_queue_ptr" => {
+                (0, vec![], tcx.mk_imm_ptr(tcx.types.u8))
+            }
 
             ref other => {
                 struct_span_err!(