b7e5148bbd
initial SPARC support
### UPDATE
Can now compile `no_std` executables with:
```
$ cargo new --bin app && cd $_
$ edit Cargo.toml && tail -n2 $_
[dependencies]
core = { path = "/path/to/rust/src/libcore" }
$ edit src/main.rs && cat $_
#![feature(lang_items)]
#![no_std]
#![no_main]
#[no_mangle]
pub fn _start() -> ! {
loop {}
}
#[lang = "panic_fmt"]
fn panic_fmt() -> ! {
loop {}
}
$ edit sparc-none-elf.json && cat $_
{
"arch": "sparc",
"data-layout": "E-m:e-p:32:32-i64:64-f128:64-n32-S64",
"executables": true,
"llvm-target": "sparc",
"os": "none",
"panic-strategy": "abort",
"target-endian": "big",
"target-pointer-width": "32"
}
$ cargo rustc --target sparc-none-elf -- -C linker=sparc-unknown-elf-gcc -C link-args=-nostartfiles
$ file target/sparc-none-elf/debug/app
app: ELF 32-bit MSB executable, SPARC, version 1 (SYSV), statically linked, not stripped
$ sparc-unknown-elf-readelf -h target/sparc-none-elf/debug/app
ELF Header:
Magic: 7f 45 4c 46 01 02 01 00 00 00 00 00 00 00 00 00
Class: ELF32
Data: 2's complement, big endian
Version: 1 (current)
OS/ABI: UNIX - System V
ABI Version: 0
Type: EXEC (Executable file)
Machine: Sparc
Version: 0x1
Entry point address: 0x10074
Start of program headers: 52 (bytes into file)
Start of section headers: 1188 (bytes into file)
Flags: 0x0
Size of this header: 52 (bytes)
Size of program headers: 32 (bytes)
Number of program headers: 2
Size of section headers: 40 (bytes)
Number of section headers: 14
Section header string table index: 11
$ sparc-unknown-elf-objdump -Cd target/sparc-none-elf/debug/app
target/sparc-none-elf/debug/app: file format elf32-sparc
Disassembly of section .text:
00010074 <_start>:
10074: 9d e3 bf 98 save %sp, -104, %sp
10078: 10 80 00 02 b 10080 <_start+0xc>
1007c: 01 00 00 00 nop
10080: 10 80 00 02 b 10088 <_start+0x14>
10084: 01 00 00 00 nop
10088: 10 80 00 00 b 10088 <_start+0x14>
1008c: 01 00 00 00 nop
```
---
Someone wants to attempt launching some Rust [into space](https://www.reddit.com/r/rust/comments/5h76oa/c_interop/) but their platform is based on the SPARCv8 architecture. Let's not block them by enabling LLVM's SPARC backend.
Something very important that they'll also need is the "cabi" stuff as they'll be embedding some Rust code into a bigger C application (i.e. heavy use of `extern "C"`). The question there is what name(s) should we use for "target_arch" as the "cabi" implementation [varies according to that parameter](https://github.com/rust-lang/rust/blob/1.13.0/src/librustc_trans/abi.rs#L498-L523).
AFAICT, SPARCv8 is a 32-bit architecture and SPARCv9 is a 64-bit architecture. And, LLVM uses `sparc`, `sparcv9` and `sparcel` for [the architecture triple](ac1c94226e/include/llvm/ADT/Triple.h (L67-L69)) so perhaps we should use `target_arch = "sparc"` (32-bit) and `target_arch = "sparcv9"` (64-bit) as well.
r? @alexcrichton This PR only enables this LLVM backend when rustbuild is used. Do I also need to implement this for the old Makefile-based build system? Or are all our nightlies now being generated using rustbuild?
cc @brson
178 lines
4.2 KiB
Rust
178 lines
4.2 KiB
Rust
// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
//! The Rust compiler.
|
|
//!
|
|
//! # Note
|
|
//!
|
|
//! This API is completely unstable and subject to change.
|
|
|
|
#![crate_name = "rustc_trans"]
|
|
#![unstable(feature = "rustc_private", issue = "27812")]
|
|
#![crate_type = "dylib"]
|
|
#![crate_type = "rlib"]
|
|
#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
|
|
html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
|
|
html_root_url = "https://doc.rust-lang.org/nightly/")]
|
|
#![cfg_attr(not(stage0), deny(warnings))]
|
|
|
|
#![feature(associated_consts)]
|
|
#![feature(box_patterns)]
|
|
#![feature(box_syntax)]
|
|
#![feature(const_fn)]
|
|
#![feature(custom_attribute)]
|
|
#![allow(unused_attributes)]
|
|
#![feature(libc)]
|
|
#![feature(quote)]
|
|
#![feature(rustc_diagnostic_macros)]
|
|
#![feature(rustc_private)]
|
|
#![feature(slice_patterns)]
|
|
#![feature(staged_api)]
|
|
#![feature(unicode)]
|
|
#![feature(conservative_impl_trait)]
|
|
|
|
use rustc::dep_graph::WorkProduct;
|
|
|
|
extern crate arena;
|
|
extern crate flate;
|
|
extern crate getopts;
|
|
extern crate graphviz;
|
|
extern crate libc;
|
|
#[macro_use] extern crate rustc;
|
|
extern crate rustc_back;
|
|
extern crate rustc_data_structures;
|
|
extern crate rustc_incremental;
|
|
pub extern crate rustc_llvm as llvm;
|
|
extern crate rustc_platform_intrinsics as intrinsics;
|
|
extern crate serialize;
|
|
extern crate rustc_const_math;
|
|
extern crate rustc_const_eval;
|
|
#[macro_use]
|
|
#[no_link]
|
|
extern crate rustc_bitflags;
|
|
|
|
#[macro_use] extern crate log;
|
|
#[macro_use] extern crate syntax;
|
|
extern crate syntax_pos;
|
|
extern crate rustc_errors as errors;
|
|
|
|
pub use rustc::session;
|
|
pub use rustc::middle;
|
|
pub use rustc::lint;
|
|
pub use rustc::util;
|
|
|
|
pub use base::trans_crate;
|
|
pub use disr::Disr;
|
|
|
|
pub mod back {
|
|
pub use rustc::hir::svh;
|
|
|
|
pub mod archive;
|
|
pub mod linker;
|
|
pub mod link;
|
|
pub mod lto;
|
|
pub mod symbol_export;
|
|
pub mod symbol_names;
|
|
pub mod write;
|
|
pub mod msvc;
|
|
pub mod rpath;
|
|
}
|
|
|
|
pub mod diagnostics;
|
|
|
|
#[macro_use]
|
|
mod macros;
|
|
|
|
mod abi;
|
|
mod adt;
|
|
mod asm;
|
|
mod assert_module_sources;
|
|
mod attributes;
|
|
mod base;
|
|
mod builder;
|
|
mod cabi_aarch64;
|
|
mod cabi_arm;
|
|
mod cabi_asmjs;
|
|
mod cabi_mips;
|
|
mod cabi_mips64;
|
|
mod cabi_msp430;
|
|
mod cabi_powerpc;
|
|
mod cabi_powerpc64;
|
|
mod cabi_s390x;
|
|
mod cabi_sparc;
|
|
mod cabi_x86;
|
|
mod cabi_x86_64;
|
|
mod cabi_x86_win64;
|
|
mod callee;
|
|
mod cleanup;
|
|
mod collector;
|
|
mod common;
|
|
mod consts;
|
|
mod context;
|
|
mod debuginfo;
|
|
mod declare;
|
|
mod disr;
|
|
mod glue;
|
|
mod intrinsic;
|
|
mod machine;
|
|
mod meth;
|
|
mod mir;
|
|
mod monomorphize;
|
|
mod partitioning;
|
|
mod symbol_map;
|
|
mod symbol_names_test;
|
|
mod trans_item;
|
|
mod tvec;
|
|
mod type_;
|
|
mod type_of;
|
|
mod value;
|
|
|
|
#[derive(Clone)]
|
|
pub struct ModuleTranslation {
|
|
/// The name of the module. When the crate may be saved between
|
|
/// compilations, incremental compilation requires that name be
|
|
/// unique amongst **all** crates. Therefore, it should contain
|
|
/// something unique to this crate (e.g., a module path) as well
|
|
/// as the crate name and disambiguator.
|
|
pub name: String,
|
|
pub symbol_name_hash: u64,
|
|
pub source: ModuleSource,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub enum ModuleSource {
|
|
/// Copy the `.o` files or whatever from the incr. comp. directory.
|
|
Preexisting(WorkProduct),
|
|
|
|
/// Rebuild from this LLVM module.
|
|
Translated(ModuleLlvm),
|
|
}
|
|
|
|
#[derive(Copy, Clone)]
|
|
pub struct ModuleLlvm {
|
|
pub llcx: llvm::ContextRef,
|
|
pub llmod: llvm::ModuleRef,
|
|
}
|
|
|
|
unsafe impl Send for ModuleTranslation { }
|
|
unsafe impl Sync for ModuleTranslation { }
|
|
|
|
pub struct CrateTranslation {
|
|
pub modules: Vec<ModuleTranslation>,
|
|
pub metadata_module: ModuleTranslation,
|
|
pub link: middle::cstore::LinkMeta,
|
|
pub metadata: Vec<u8>,
|
|
pub exported_symbols: back::symbol_export::ExportedSymbols,
|
|
pub no_builtins: bool,
|
|
pub windows_subsystem: Option<String>,
|
|
pub linker_info: back::linker::LinkerInfo
|
|
}
|
|
|
|
__build_diagnostic_array! { librustc_trans, DIAGNOSTICS }
|