Support Harvard architectures.

Author: DiamondLovesYou

src/librustc_codegen_llvm/abi.rs

@@ -11,7 +11,7 @@ use rustc_target::abi::call::ArgType;
 
 use rustc_codegen_ssa::traits::*;
 
-use rustc_target::abi::{HasDataLayout, LayoutOf, Size, TyLayout, Abi as LayoutAbi};
+use rustc_target::abi::{LayoutOf, Size, TyLayout, Abi as LayoutAbi};
 use rustc::ty::{self, Ty, Instance};
 use rustc::ty::layout;
 
@@ -311,7 +311,6 @@ pub trait FnTypeExt<'tcx> {
                       cx: &CodegenCx<'ll, 'tcx>,
                       abi: Abi);
     fn llvm_type(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type;
-    fn ptr_to_llvm_type(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type;
     fn llvm_cconv(&self) -> llvm::CallConv;
     fn apply_attrs_llfn(&self, llfn: &'ll Value);
     fn apply_attrs_callsite(&self, bx: &mut Builder<'a, 'll, 'tcx>, callsite: &'ll Value);
@@ -695,13 +694,6 @@ impl<'tcx> FnTypeExt<'tcx> for FnType<'tcx, Ty<'tcx>> {
         }
     }
 
-    fn ptr_to_llvm_type(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type {
-        unsafe {
-            llvm::LLVMPointerType(self.llvm_type(cx),
-                                  cx.data_layout().instruction_address_space as c_uint)
-        }
-    }
-
     fn llvm_cconv(&self) -> llvm::CallConv {
         match self.conv {
             Conv::C => llvm::CCallConv,

src/librustc_codegen_llvm/context.rs

@@ -89,6 +89,7 @@ pub struct CodegenCx<'ll, 'tcx: 'll> {
     const_addr_space: AddrSpaceIdx,
     mutable_addr_space: AddrSpaceIdx,
     flat_addr_space: AddrSpaceIdx,
+    instruction_addr_space: AddrSpaceIdx,
 
     pub dbg_cx: Option<debuginfo::CrateDebugContext<'ll, 'tcx>>,
 
@@ -299,6 +300,11 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
               .get(&AddrSpaceKind::Flat)
               .map(|v| v.index )
               .unwrap_or_default();
+        let instruction_addr_space =
+            tcx.sess.target.target.options.addr_spaces
+              .get(&AddrSpaceKind::Instruction)
+              .map(|v| v.index )
+              .unwrap_or_default();
 
         CodegenCx {
             tcx,
@@ -325,6 +331,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
             const_addr_space,
             mutable_addr_space,
             flat_addr_space,
+            instruction_addr_space,
 
             dbg_cx,
             eh_personality: Cell::new(None),
@@ -497,6 +504,9 @@ impl MiscMethods<'tcx> for CodegenCx<'ll, 'tcx> {
 
         from_props.shared_with.contains(&to_kind)
     }
+    fn inst_addr_space(&self) -> AddrSpaceIdx {
+        self.instruction_addr_space
+    }
     fn alloca_addr_space(&self) -> AddrSpaceIdx {
         self.alloca_addr_space
     }

src/librustc_codegen_llvm/declare.rs

@@ -24,6 +24,7 @@ use context::CodegenCx;
 use type_::Type;
 use rustc_codegen_ssa::traits::*;
 use value::Value;
+use common::val_ty;
 
 /// Declare a function.
 ///
@@ -40,6 +41,7 @@ fn declare_raw_fn(
     let llfn = unsafe {
         llvm::LLVMRustGetOrInsertFunction(cx.llmod, namebuf.as_ptr(), ty)
     };
+    assert_eq!(val_ty(llfn).address_space(), cx.inst_addr_space());
 
     llvm::SetFunctionCallConv(llfn, callconv);
     // Function addresses in Rust are never significant, allowing functions to

src/librustc_codegen_llvm/type_.rs

@@ -337,7 +337,8 @@ impl LayoutTypeMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         ty.llvm_type(self)
     }
     fn fn_ptr_backend_type(&self, ty: &FnType<'tcx, Ty<'tcx>>) -> &'ll Type {
-        ty.ptr_to_llvm_type(self)
+        self.type_as_ptr_to(ty.llvm_type(self), self.inst_addr_space())
+
     }
     fn reg_backend_type(&self, ty: &Reg) -> &'ll Type {
         ty.llvm_type(self)

src/librustc_codegen_ssa/meth.rs

@@ -81,7 +81,7 @@ pub fn get_vtable<'tcx, Cx: CodegenMethods<'tcx>>(
     }
 
     // Not in the cache. Build it.
-    let nullptr = cx.const_null(cx.type_i8p());
+    let nullptr = cx.const_null(cx.type_inst_i8p());
 
     let methods_root;
     let methods = if let Some(trait_ref) = trait_ref {

src/librustc_codegen_ssa/traits/misc.rs

@@ -29,6 +29,7 @@ pub trait MiscMethods<'tcx>: BackendTypes {
     fn create_used_variable(&self);
 
     fn can_cast_addr_space(&self, _from: AddrSpaceIdx, _to: AddrSpaceIdx) -> bool { true }
+    fn inst_addr_space(&self) -> AddrSpaceIdx { Default::default() }
     fn alloca_addr_space(&self) -> AddrSpaceIdx { Default::default() }
     fn const_addr_space(&self) -> AddrSpaceIdx { Default::default() }
     fn mutable_addr_space(&self) -> AddrSpaceIdx { Default::default() }

src/librustc_codegen_ssa/traits/type_.rs

@@ -84,6 +84,9 @@ pub trait DerivedTypeMethods<'tcx>: BaseTypeMethods<'tcx> + MiscMethods<'tcx> {
     fn type_i8p_as(&self, addr_space: AddrSpaceIdx) -> Self::Type {
         self.type_as_ptr_to(self.type_i8(), addr_space)
     }
+    fn type_inst_i8p(&self) -> Self::Type {
+        self.type_i8p_as(self.inst_addr_space())
+    }
     fn type_alloca_i8p(&self) -> Self::Type {
         self.type_i8p_as(self.alloca_addr_space())
     }
@@ -214,6 +217,9 @@ pub trait DerivedTypeMethods<'tcx>: BaseTypeMethods<'tcx> + MiscMethods<'tcx> {
             _ => { },
         }
     }
+    fn type_ptr_to_inst(&self, ty: Self::Type) -> Self::Type {
+        self.type_as_ptr_to(ty, self.inst_addr_space())
+    }
     fn type_ptr_to_alloca(&self, ty: Self::Type) -> Self::Type {
         self.type_as_ptr_to(ty, self.alloca_addr_space())
     }

src/librustc_target/abi/mod.rs

@@ -31,8 +31,7 @@ pub struct TargetDataLayout {
     pub vector_align: Vec<(Size, AbiAndPrefAlign)>,
 
     pub alloca_address_space: AddrSpaceIdx,
-
-    pub instruction_address_space: u32,
+    pub instruction_address_space: AddrSpaceIdx,
 }
 
 impl Default for TargetDataLayout {
@@ -54,11 +53,11 @@ impl Default for TargetDataLayout {
             pointer_align: AbiAndPrefAlign::new(align(64)),
             aggregate_align: AbiAndPrefAlign { abi: align(0), pref: align(64) },
             alloca_address_space: Default::default(),
+            instruction_address_space: Default::default(),
             vector_align: vec![
                 (Size::from_bits(64), AbiAndPrefAlign::new(align(64))),
                 (Size::from_bits(128), AbiAndPrefAlign::new(align(128))),
             ],
-            instruction_address_space: 0,
         }
     }
 }
@@ -128,6 +127,11 @@ impl TargetDataLayout {
                   let align = align(a, p)?;
                   resize_and_set(&mut dl.pointers, idx, Some((size, align)));
                 },
+                [ref p] if p.starts_with("P") => {
+                    let idx = parse_bits(&p[1..], "u32",
+                                         "instruction address space")? as u32;
+                    dl.instruction_address_space = AddrSpaceIdx(idx);
+                }
                [s, ref a..] if s.starts_with("i") => {
                     let bits = match s[1..].parse::<u64>() {
                         Ok(bits) => bits,

src/librustc_target/spec/mod.rs

@@ -288,6 +288,8 @@ pub enum AddrSpaceKind {
     ReadOnly,
     /// aka global
     ReadWrite,
+    /// For Harvard architectures, the program instruction's address space
+    Instruction,
     Named(String),
 }
 
@@ -299,6 +301,7 @@ impl FromStr for AddrSpaceKind {
             "alloca" => AddrSpaceKind::Alloca,
             "readonly" => AddrSpaceKind::ReadOnly,
             "readwrite" => AddrSpaceKind::ReadWrite,
+            "instruction" => AddrSpaceKind::Instruction,
             named => AddrSpaceKind::Named(named.into()),
         })
     }
@@ -310,6 +313,7 @@ impl fmt::Display for AddrSpaceKind {
             &AddrSpaceKind::Alloca => "alloca",
             &AddrSpaceKind::ReadOnly => "readonly",
             &AddrSpaceKind::ReadWrite => "readwrite",
+            &AddrSpaceKind::Instruction => "instruction",
             &AddrSpaceKind::Named(ref s) => s,
         })
     }
@@ -389,10 +393,13 @@ impl Default for AddrSpaces {
     fn default() -> Self {
         let mut asp = BTreeMap::new();
 
-        let kinds = vec![AddrSpaceKind::ReadOnly,
-                         AddrSpaceKind::ReadWrite,
-                         AddrSpaceKind::Alloca,
-                         AddrSpaceKind::Flat, ];
+        let kinds = vec![
+            AddrSpaceKind::ReadOnly,
+            AddrSpaceKind::ReadWrite,
+            AddrSpaceKind::Alloca,
+            AddrSpaceKind::Flat,
+            AddrSpaceKind::Instruction,
+        ];
 
         let insert = |asp: &mut BTreeMap<_, _>, kind, idx| {
             let props = AddrSpaceProps {