From 08f05126cd3c6027c8af29b0665bee314b2aac1d Mon Sep 17 00:00:00 2001 From: ILYONG CHO Date: Thu, 29 Nov 2012 17:29:13 +0900 Subject: [PATCH 1/3] change libuv for android target --- .gitmodules | 2 +- src/libuv | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.gitmodules b/.gitmodules index d750f8eb5b781..d29179a8c4ace 100644 --- a/.gitmodules +++ b/.gitmodules @@ -3,4 +3,4 @@ url = git://github.com/brson/llvm.git [submodule "src/libuv"] path = src/libuv - url = git://github.com/graydon/libuv.git + url = git://github.com/ILyoan/libuv.git diff --git a/src/libuv b/src/libuv index 1170ffba3ac51..4d392c86feb63 160000 --- a/src/libuv +++ b/src/libuv @@ -1 +1 @@ -Subproject commit 1170ffba3ac5191930b40c897d4569a9d8a296a3 +Subproject commit 4d392c86feb6389f550d8110d36fa90d66c09251 From 97d0a1a05fffeb358757ec98009ca984b5727a50 Mon Sep 17 00:00:00 2001 From: kyeongwoon Date: Fri, 30 Nov 2012 09:21:49 +0900 Subject: [PATCH 2/3] Support ARM and Android --- src/libcore/cleanup.rs | 3 + src/libcore/libc.rs | 12 +++ src/libcore/os.rs | 13 ++- src/libcore/path.rs | 2 + src/libcore/run.rs | 2 + src/librustc/back/arm.rs | 85 +++++++++++++++++++ src/librustc/back/link.rs | 21 ++++- src/librustc/back/rpath.rs | 4 +- src/librustc/back/x86.rs | 4 + src/librustc/back/x86_64.rs | 6 ++ src/librustc/driver/driver.rs | 18 +++- src/librustc/driver/session.rs | 3 +- src/librustc/metadata/loader.rs | 5 +- src/librustc/middle/trans/base.rs | 23 +++++- src/librustc/middle/trans/foreign.rs | 11 +++ src/librustc/rustc.rc | 2 + src/libstd/net_tcp.rs | 2 + src/libstd/uv_ll.rs | 15 ++++ src/rt/arch/arm/_context.S | 47 +++++++++++ src/rt/arch/arm/ccall.S | 27 ++++++ src/rt/arch/arm/context.cpp | 36 ++++++++ src/rt/arch/arm/context.h | 43 ++++++++++ src/rt/arch/arm/gpr.cpp | 15 ++++ src/rt/arch/arm/gpr.h | 23 ++++++ src/rt/arch/arm/record_sp.S | 61 ++++++++++++++ src/rt/arch/arm/regs.h | 21 +++++ src/rt/rust_android_dummy.cpp | 61 ++++++++++++++ src/rt/rust_android_dummy.h | 5 ++ src/rt/rust_builtin.cpp | 21 +++++ src/rt/rust_sched_loop.cpp | 1 + src/rt/rust_task.h | 3 + src/rustllvm/CMakeLists.txt | 119 +++++++++++++++++++++++++++ src/rustllvm/RustWrapper.cpp | 12 +++ src/rustllvm/rustllvm.def.in | 14 ++-- 34 files changed, 718 insertions(+), 22 deletions(-) create mode 100644 src/librustc/back/arm.rs create mode 100644 src/rt/arch/arm/_context.S create mode 100644 src/rt/arch/arm/ccall.S create mode 100644 src/rt/arch/arm/context.cpp create mode 100644 src/rt/arch/arm/context.h create mode 100644 src/rt/arch/arm/gpr.cpp create mode 100644 src/rt/arch/arm/gpr.h create mode 100644 src/rt/arch/arm/record_sp.S create mode 100644 src/rt/arch/arm/regs.h create mode 100644 src/rt/rust_android_dummy.cpp create mode 100644 src/rt/rust_android_dummy.h create mode 100644 src/rustllvm/CMakeLists.txt diff --git a/src/libcore/cleanup.rs b/src/libcore/cleanup.rs index 9fd0a50a99c5e..e5e8572ca75da 100644 --- a/src/libcore/cleanup.rs +++ b/src/libcore/cleanup.rs @@ -40,11 +40,13 @@ struct AllocHeader { priv opaque: () } struct MemoryRegion { priv opaque: () } #[cfg(target_arch="x86")] +#[cfg(target_arch="arm")] struct Registers { data: [u32 * 16] } #[cfg(target_arch="x86")] +#[cfg(target_arch="arm")] struct Context { regs: Registers, next: *Context, @@ -70,6 +72,7 @@ struct BoxedRegion { } #[cfg(target_arch="x86")] +#[cfg(target_arch="arm")] struct Task { // Public fields refcount: intptr_t, // 0 diff --git a/src/libcore/libc.rs b/src/libcore/libc.rs index ae29bbe308512..0af684e5f7cd0 100644 --- a/src/libcore/libc.rs +++ b/src/libcore/libc.rs @@ -198,12 +198,14 @@ mod types { // Standard types that are scalar but vary by OS and arch. #[cfg(target_os = "linux")] + #[cfg(target_os = "android")] pub mod os { pub mod common { pub mod posix01 {} } #[cfg(target_arch = "x86")] + #[cfg(target_arch = "arm")] pub mod arch { pub mod c95 { pub type c_char = i8; @@ -726,6 +728,7 @@ pub mod consts { #[cfg(target_os = "linux")] + #[cfg(target_os = "android")] pub mod os { pub mod c95 { pub const EXIT_FAILURE : int = 1; @@ -1171,6 +1174,7 @@ pub mod funcs { #[cfg(target_os = "linux")] + #[cfg(target_os = "android")] #[cfg(target_os = "macos")] #[cfg(target_os = "freebsd")] pub mod posix88 { @@ -1182,6 +1186,7 @@ pub mod funcs { #[cfg(target_os = "linux")] #[cfg(target_os = "freebsd")] + #[cfg(target_os = "android")] fn fstat(fildes: c_int, buf: *mut stat) -> c_int; #[cfg(target_os = "macos")] @@ -1193,6 +1198,7 @@ pub mod funcs { #[cfg(target_os = "linux")] #[cfg(target_os = "freebsd")] + #[cfg(target_os = "android")] fn stat(path: *c_char, buf: *mut stat) -> c_int; #[cfg(target_os = "macos")] @@ -1279,6 +1285,7 @@ pub mod funcs { } #[cfg(target_os = "linux")] + #[cfg(target_os = "android")] #[cfg(target_os = "macos")] #[cfg(target_os = "freebsd")] pub mod posix01 { @@ -1287,6 +1294,7 @@ pub mod funcs { pub extern mod stat_ { #[cfg(target_os = "linux")] #[cfg(target_os = "freebsd")] + #[cfg(target_os = "android")] fn lstat(path: *c_char, buf: *mut stat) -> c_int; #[cfg(target_os = "macos")] @@ -1303,6 +1311,7 @@ pub mod funcs { fn fsync(fd: c_int) -> c_int; #[cfg(target_os = "linux")] + #[cfg(target_os = "android")] fn fdatasync(fd: c_int) -> c_int; fn setenv(name: *c_char, val: *c_char, @@ -1335,6 +1344,7 @@ pub mod funcs { #[cfg(target_os = "win32")] #[cfg(target_os = "linux")] + #[cfg(target_os = "android")] #[cfg(target_os = "macos")] #[cfg(target_os = "freebsd")] pub mod posix08 { @@ -1363,6 +1373,7 @@ pub mod funcs { #[cfg(target_os = "linux")] + #[cfg(target_os = "android")] #[cfg(target_os = "win32")] pub mod bsd44 { } @@ -1380,6 +1391,7 @@ pub mod funcs { } #[cfg(target_os = "linux")] + #[cfg(target_os = "android")] pub mod extra { } diff --git a/src/libcore/os.rs b/src/libcore/os.rs index 3b340d6de791d..2bda09ccd66c2 100644 --- a/src/libcore/os.rs +++ b/src/libcore/os.rs @@ -295,6 +295,7 @@ pub fn fsync_fd(fd: c_int, _level: io::fsync::Level) -> c_int { } #[cfg(target_os = "linux")] +#[cfg(target_os = "android")] pub fn fsync_fd(fd: c_int, level: io::fsync::Level) -> c_int { use libc::funcs::posix01::unistd::*; match level { @@ -407,6 +408,7 @@ pub fn self_exe_path() -> Option { } #[cfg(target_os = "linux")] + #[cfg(target_os = "android")] fn load_self() -> Option<~str> { use libc::funcs::posix01::unistd::readlink; do fill_charp_buf() |buf, sz| { @@ -790,6 +792,7 @@ fn real_args() -> ~[~str] { } #[cfg(target_os = "linux")] +#[cfg(target_os = "android")] #[cfg(target_os = "freebsd")] fn real_args() -> ~[~str] { unsafe { @@ -901,6 +904,14 @@ mod consts { pub fn dll_suffix() -> ~str { ~".so" } } +#[cfg(target_os = "android")] +mod consts { + pub fn sysname() -> ~str { ~"android" } + pub fn exe_suffix() -> ~str { ~"" } + pub fn dll_suffix() -> ~str { ~".so" } +} + + #[cfg(target_os = "win32")] mod consts { pub fn sysname() -> ~str { ~"win32" } @@ -915,7 +926,7 @@ pub fn arch() -> ~str { ~"x86" } pub fn arch() -> ~str { ~"x86_64" } #[cfg(target_arch = "arm")] -pub fn arch() -> str { ~"arm" } +pub fn arch() -> ~str { ~"arm" } #[cfg(test)] #[allow(non_implicitly_copyable_typarams)] diff --git a/src/libcore/path.rs b/src/libcore/path.rs index 14c7c288bddfb..fd5b9e6e0ade1 100644 --- a/src/libcore/path.rs +++ b/src/libcore/path.rs @@ -87,8 +87,10 @@ pub pure fn Path(s: &str) -> Path { } #[cfg(target_os = "linux")] +#[cfg(target_os = "android")] mod stat { #[cfg(target_arch = "x86")] + #[cfg(target_arch = "arm")] pub mod arch { use libc; diff --git a/src/libcore/run.rs b/src/libcore/run.rs index b753c647627ae..8bc128baf60ba 100644 --- a/src/libcore/run.rs +++ b/src/libcore/run.rs @@ -385,6 +385,7 @@ pub fn waitpid(pid: pid_t) -> int { #[cfg(unix)] fn waitpid_os(pid: pid_t) -> int { #[cfg(target_os = "linux")] + #[cfg(target_os = "android")] fn WIFEXITED(status: i32) -> bool { (status & 0xffi32) == 0i32 } @@ -396,6 +397,7 @@ pub fn waitpid(pid: pid_t) -> int { } #[cfg(target_os = "linux")] + #[cfg(target_os = "android")] fn WEXITSTATUS(status: i32) -> i32 { (status >> 8i32) & 0xffi32 } diff --git a/src/librustc/back/arm.rs b/src/librustc/back/arm.rs new file mode 100644 index 0000000000000..2c4e0af0f2d28 --- /dev/null +++ b/src/librustc/back/arm.rs @@ -0,0 +1,85 @@ +// Copyright 2012 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use back::target_strs; +use driver::session; +use session::sess_os_to_meta_os; +use metadata::loader::meta_section_name; + +fn get_target_strs(target_os: session::os) -> target_strs::t { + return { + module_asm: ~"", + + meta_sect_name: meta_section_name(sess_os_to_meta_os(target_os)), + + data_layout: match target_os { + session::os_macos => { + ~"e-p:32:32:32" + + ~"-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" + + ~"-f32:32:32-f64:64:64" + + ~"-v64:64:64-v128:64:128" + + ~"-a0:0:64-n32" + } + + session::os_win32 => { + ~"e-p:32:32:32" + + ~"-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" + + ~"-f32:32:32-f64:64:64" + + ~"-v64:64:64-v128:64:128" + + ~"-a0:0:64-n32" + } + + session::os_linux => { + ~"e-p:32:32:32" + + ~"-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" + + ~"-f32:32:32-f64:64:64" + + ~"-v64:64:64-v128:64:128" + + ~"-a0:0:64-n32" + } + + session::os_android => { + ~"e-p:32:32:32" + + ~"-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" + + ~"-f32:32:32-f64:64:64" + + ~"-v64:64:64-v128:64:128" + + ~"-a0:0:64-n32" + } + + session::os_freebsd => { + ~"e-p:32:32:32" + + ~"-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" + + ~"-f32:32:32-f64:64:64" + + ~"-v64:64:64-v128:64:128" + + ~"-a0:0:64-n32" + } + }, + + target_triple: match target_os { + session::os_macos => ~"arm-apple-darwin", + session::os_win32 => ~"arm-pc-mingw32", + session::os_linux => ~"arm-unknown-linux", + session::os_android => ~"arm-unknown-android", + session::os_freebsd => ~"arm-unknown-freebsd" + }, + + cc_args: ~[~"-marm"] + }; +} + + +// +// Local Variables: +// mode: rust +// fill-column: 78; +// indent-tabs-mode: nil +// c-basic-offset: 4 +// buffer-file-coding-system: utf-8-unix +// End: +// diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs index a2b67e8380bd0..b21371421f04a 100644 --- a/src/librustc/back/link.rs +++ b/src/librustc/back/link.rs @@ -679,9 +679,12 @@ fn link_binary(sess: Session, } let output = if sess.building_library { - let long_libname = - os::dll_filename(fmt!("%s-%s-%s", - lm.name, lm.extras_hash, lm.vers)); + let libname = fmt!("%s-%s-%s", lm.name, lm.extras_hash, lm.vers); + let long_libname = match sess.targ_cfg.os { + session::os_win32 => libname + ~".dll", + session::os_macos => ~"lib" + libname + ~".dylib", + _ => ~"lib" + libname + ".so" + }; debug!("link_meta.name: %s", lm.name); debug!("long_libname: %s", long_libname); debug!("out_filename: %s", out_filename.to_str()); @@ -704,7 +707,10 @@ fn link_binary(sess: Session, // For win32, there is no cc command, // so we add a condition to make it use gcc. let cc_prog: ~str = - if sess.targ_cfg.os == session::os_win32 { ~"gcc" } else { ~"cc" }; + if sess.targ_cfg.os == session::os_android { + ~"arm-linux-androideabi-g++" + } else if sess.targ_cfg.os == session::os_win32 { ~"gcc" } + else { ~"cc" }; // The invocations of cc share some flags across platforms let mut cc_args = @@ -777,6 +783,11 @@ fn link_binary(sess: Session, // have to be explicit about linking to it. See #2510 cc_args.push(~"-lm"); } + else if sess.targ_cfg.os == session::os_android { + cc_args.push_all(~[~"-ldl", ~"-llog", ~"-lsupc++", + ~"-lgnustl_shared"]); + cc_args.push(~"-lm"); + } if sess.targ_cfg.os == session::os_freebsd { cc_args.push_all(~[~"-pthread", ~"-lrt", @@ -797,7 +808,9 @@ fn link_binary(sess: Session, } // Stack growth requires statically linking a __morestack function + if sess.targ_cfg.os != session::os_android { cc_args.push(~"-lmorestack"); + } // FIXME (#2397): At some point we want to rpath our guesses as to where // extern libraries might live, based on the addl_lib_search_paths diff --git a/src/librustc/back/rpath.rs b/src/librustc/back/rpath.rs index adb0b659b144e..8f6db4b894db8 100644 --- a/src/librustc/back/rpath.rs +++ b/src/librustc/back/rpath.rs @@ -122,7 +122,8 @@ fn get_rpath_relative_to_output(os: session::os, // Mac doesn't appear to support $ORIGIN let prefix = match os { - session::os_linux | session::os_freebsd => "$ORIGIN", + session::os_android |session::os_linux | session::os_freebsd + => "$ORIGIN", session::os_macos => "@executable_path", session::os_win32 => util::unreachable() }; @@ -318,6 +319,7 @@ mod test { #[test] #[cfg(target_os = "linux")] + #[cfg(target_os = "andorid")] fn test_rpath_relative() { let o = session::os_linux; let res = get_rpath_relative_to_output(o, diff --git a/src/librustc/back/x86.rs b/src/librustc/back/x86.rs index 43f134702cbaa..3d78e75681d09 100644 --- a/src/librustc/back/x86.rs +++ b/src/librustc/back/x86.rs @@ -34,6 +34,9 @@ fn get_target_strs(target_os: session::os) -> target_strs::t { session::os_linux => { ~"e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32" } + session::os_android => { + ~"e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32" + } session::os_freebsd => { ~"e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32" @@ -44,6 +47,7 @@ fn get_target_strs(target_os: session::os) -> target_strs::t { session::os_macos => ~"i686-apple-darwin", session::os_win32 => ~"i686-pc-mingw32", session::os_linux => ~"i686-unknown-linux-gnu", + session::os_android => ~"i686-unknown-android-gnu", session::os_freebsd => ~"i686-unknown-freebsd" }, diff --git a/src/librustc/back/x86_64.rs b/src/librustc/back/x86_64.rs index 1d459aaa6f3f8..15d8f694d61d8 100644 --- a/src/librustc/back/x86_64.rs +++ b/src/librustc/back/x86_64.rs @@ -38,6 +38,11 @@ fn get_target_strs(target_os: session::os) -> target_strs::t { ~"f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-"+ ~"s0:64:64-f80:128:128-n8:16:32:64-S128" } + session::os_android => { + ~"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"+ + ~"f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-"+ + ~"s0:64:64-f80:128:128-n8:16:32:64-S128" + } session::os_freebsd => { ~"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"+ @@ -50,6 +55,7 @@ fn get_target_strs(target_os: session::os) -> target_strs::t { session::os_macos => ~"x86_64-apple-darwin", session::os_win32 => ~"x86_64-pc-mingw32", session::os_linux => ~"x86_64-unknown-linux-gnu", + session::os_android => ~"x86_64-unknown-android-gnu", session::os_freebsd => ~"x86_64-unknown-freebsd", }, diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index db15a57208218..a9030316def13 100644 --- a/src/librustc/driver/driver.rs +++ b/src/librustc/driver/driver.rs @@ -10,7 +10,7 @@ // except according to those terms. use back::link; -use back::{x86, x86_64}; +use back::{arm, x86, x86_64}; use front; use lib::llvm::llvm; use metadata::{creader, cstore, filesearch}; @@ -72,9 +72,18 @@ fn default_configuration(sess: Session, argv0: ~str, input: input) -> session::os_win32 => ~"msvcrt.dll", session::os_macos => ~"libc.dylib", session::os_linux => ~"libc.so.6", + session::os_android => ~"libc.so", session::os_freebsd => ~"libc.so.7" // _ { "libc.so" } }; + let tos = match sess.targ_cfg.os { + session::os_win32 => ~"win32", + session::os_macos => ~"macos", + session::os_linux => ~"linux", + session::os_android => ~"android", + session::os_freebsd => ~"freebsd" + // _ { "libc.so" } + }; let mk = attr::mk_name_value_item_str; @@ -86,7 +95,8 @@ fn default_configuration(sess: Session, argv0: ~str, input: input) -> return ~[ // Target bindings. attr::mk_word_item(os::family()), - mk(~"target_os", os::sysname()), + //mk(~"target_os", os::sysname()), + mk(~"target_os", tos), mk(~"target_family", os::family()), mk(~"target_arch", arch), mk(~"target_word_size", wordsz), @@ -418,6 +428,8 @@ fn get_os(triple: ~str) -> Option { Some(session::os_macos) } else if str::contains(triple, ~"linux") { Some(session::os_linux) + } else if str::contains(triple, ~"android") { + Some(session::os_android) } else if str::contains(triple, ~"freebsd") { Some(session::os_freebsd) } else { None } @@ -457,7 +469,7 @@ fn build_target_config(sopts: @session::options, let target_strs = match arch { session::arch_x86 => x86::get_target_strs(os), session::arch_x86_64 => x86_64::get_target_strs(os), - session::arch_arm => x86::get_target_strs(os) + session::arch_arm => arm::get_target_strs(os) }; let target_cfg: @session::config = @{os: os, arch: arch, target_strs: target_strs, int_type: int_type, diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs index 8ea5052afaf71..11a57ffe9a860 100644 --- a/src/librustc/driver/session.rs +++ b/src/librustc/driver/session.rs @@ -28,7 +28,7 @@ use syntax::parse::parse_sess; use syntax::{ast, codemap}; use syntax; -enum os { os_win32, os_macos, os_linux, os_freebsd, } +enum os { os_win32, os_macos, os_linux, os_android, os_freebsd, } impl os : cmp::Eq { pure fn eq(&self, other: &os) -> bool { @@ -324,6 +324,7 @@ fn sess_os_to_meta_os(os: os) -> metadata::loader::os { match os { os_win32 => loader::os_win32, os_linux => loader::os_linux, + os_android => loader::os_android, os_macos => loader::os_macos, os_freebsd => loader::os_freebsd } diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index e75329340c2fe..c3a1b2f02d440 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -32,7 +32,7 @@ use core::uint; use core::vec; export os; -export os_macos, os_win32, os_linux, os_freebsd; +export os_macos, os_win32, os_linux, os_freebsd, os_android; export ctxt; export load_library_crate; export list_file_metadata; @@ -45,6 +45,7 @@ enum os { os_macos, os_win32, os_linux, + os_android, os_freebsd } @@ -82,6 +83,7 @@ fn libname(cx: ctxt) -> {prefix: ~str, suffix: ~str} { os_win32 => return {prefix: ~"", suffix: ~".dll"}, os_macos => return {prefix: ~"lib", suffix: ~".dylib"}, os_linux => return {prefix: ~"lib", suffix: ~".so"}, + os_android => return {prefix: ~"lib", suffix: ~".so"}, os_freebsd => return {prefix: ~"lib", suffix: ~".so"} } } @@ -243,6 +245,7 @@ fn meta_section_name(os: os) -> ~str { os_macos => ~"__DATA,__note.rustc", os_win32 => ~".note.rustc", os_linux => ~".note.rustc", + os_android => ~".note.rustc", os_freebsd => ~".note.rustc" } } diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 6c042d740e1f5..3a7337154915c 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -1999,7 +1999,9 @@ fn register_fn_fuller(ccx: @crate_ctxt, sp: span, path: path, val_str(ccx.tn, llfn), node_id, ast_map::path_to_str(path, ccx.sess.parse_sess.interner)); - let is_main = is_main_name(path) && !ccx.sess.building_library; + let is_main = is_main_name(path) && (!ccx.sess.building_library || + (ccx.sess.building_library && + ccx.sess.targ_cfg.os == session::os_android)); if is_main { create_main_wrapper(ccx, sp, llfn); } llfn } @@ -2049,7 +2051,12 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef) { #[cfg(unix)] fn main_name() -> ~str { return ~"main"; } let llfty = T_fn(~[ccx.int_type, ccx.int_type], ccx.int_type); - let llfn = decl_cdecl_fn(ccx.llmod, main_name(), llfty); + + let llfn = if ccx.sess.building_library { + decl_cdecl_fn(ccx.llmod, ~"amain", llfty) + } else { + decl_cdecl_fn(ccx.llmod, main_name(), llfty) + }; let llbb = str::as_c_str(~"top", |buf| { llvm::LLVMAppendBasicBlock(llfn, buf) }); @@ -2060,8 +2067,16 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef) { val_ty(crate_map)], ccx.int_type); let start = decl_cdecl_fn(ccx.llmod, ~"rust_start", start_ty); - let args = ~[rust_main, llvm::LLVMGetParam(llfn, 0 as c_uint), - llvm::LLVMGetParam(llfn, 1 as c_uint), crate_map]; + let args = if ccx.sess.building_library { + ~[rust_main, + llvm::LLVMConstInt(T_i32(), 0u as c_ulonglong, False), + llvm::LLVMConstInt(T_i32(), 0u as c_ulonglong, False), + crate_map] + } else { + ~[rust_main, llvm::LLVMGetParam(llfn, 0 as c_uint), + llvm::LLVMGetParam(llfn, 1 as c_uint), crate_map] + }; + let result = unsafe { llvm::LLVMBuildCall(bld, start, vec::raw::to_ptr(args), args.len() as c_uint, noname()) diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs index 91e5429fe23c8..ee14c27c87f08 100644 --- a/src/librustc/middle/trans/foreign.rs +++ b/src/librustc/middle/trans/foreign.rs @@ -13,6 +13,7 @@ use back::{link, abi}; use driver::session::arch_x86_64; +use driver::session::arch_arm; use lib::llvm::{SequentiallyConsistent, Acquire, Release, Xchg}; use lib::llvm::{Struct, Array, ModuleRef, CallConv, Attribute}; use lib::llvm::{StructRetAttribute, ByValAttribute}; @@ -473,6 +474,8 @@ fn c_stack_tys(ccx: @crate_ctxt, let ret_def = !ty::type_is_bot(ret_ty) && !ty::type_is_nil(ret_ty); let x86_64 = if ccx.sess.targ_cfg.arch == arch_x86_64 { option::Some(x86_64_tys(llargtys, llretty, ret_def)) + } else if ccx.sess.targ_cfg.arch == arch_arm { + option::Some(x86_64_tys(llargtys, llretty, ret_def)) } else { option::None }; @@ -1465,6 +1468,14 @@ fn register_foreign_fn(ccx: @crate_ctxt, sp: span, register_fn_fuller(ccx, sp, path, node_id, t, lib::llvm::CCallConv, fnty) } + } else if ccx.sess.targ_cfg.arch == arch_arm { + let ret_def = !ty::type_is_bot(ret_ty) && !ty::type_is_nil(ret_ty); + let x86_64 = x86_64_tys(llargtys, llretty, ret_def); + do decl_x86_64_fn(x86_64) |fnty| { + register_fn_fuller(ccx, sp, path, node_id, + t, lib::llvm::CCallConv, fnty) + } + } else { let llfty = T_fn(llargtys, llretty); register_fn_fuller(ccx, sp, path, node_id, diff --git a/src/librustc/rustc.rc b/src/librustc/rustc.rc index 9f5866a210b1f..6c4c68dd88897 100644 --- a/src/librustc/rustc.rc +++ b/src/librustc/rustc.rc @@ -162,6 +162,8 @@ mod back { #[legacy_exports] mod upcall; #[legacy_exports] + mod arm; + #[legacy_exports] mod x86; #[legacy_exports] mod x86_64; diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs index ca365e2a7d3e3..52645c5ccb677 100644 --- a/src/libstd/net_tcp.rs +++ b/src/libstd/net_tcp.rs @@ -1285,6 +1285,7 @@ mod test { #[cfg(target_os="win32")] #[cfg(target_os="darwin")] #[cfg(target_os="linux")] + #[cfg(target_os="android")] mod tcp_ipv4_server_and_client_test { #[cfg(target_arch="x86_64")] mod impl64 { @@ -1318,6 +1319,7 @@ mod test { } } #[cfg(target_arch="x86")] + #[cfg(target_arch="arm")] mod impl32 { #[test] #[ignore(cfg(target_os = "linux"))] diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs index 46574ced2e596..db3b9f51002c7 100644 --- a/src/libstd/uv_ll.rs +++ b/src/libstd/uv_ll.rs @@ -108,6 +108,7 @@ pub type uv_tcp_t_32bit_unix_riders = { a29: *u8 }; #[cfg(target_arch="x86")] +#[cfg(target_arch="arm")] pub type uv_tcp_t_32bit_unix_riders = { a29: *u8, a30: *u8, a31: *u8, a32: *u8, a33: *u8, a34: *u8, @@ -164,6 +165,7 @@ pub type uv_write_t_32bit_unix_riders = { a13: *u8 }; #[cfg(target_arch="x86")] +#[cfg(target_arch="arm")] pub type uv_write_t_32bit_unix_riders = { a13: *u8, a14: *u8 }; @@ -191,6 +193,7 @@ pub type uv_async_t_32bit_unix_riders = { a10: *u8 }; #[cfg(target_arch="x86")] +#[cfg(target_arch="arm")] pub type uv_async_t_32bit_unix_riders = { a10: *u8, a11: *u8, a12: *u8, a13: *u8 }; @@ -219,6 +222,7 @@ pub type uv_timer_t_32bit_unix_riders = { a10: *u8, a11: *u8 }; #[cfg(target_arch="x86")] +#[cfg(target_arch="arm")] pub type uv_timer_t_32bit_unix_riders = { a10: *u8, a11: *u8, a12: *u8, a13: *u8, a14: *u8, a15: *u8, a16: *u8 @@ -248,6 +252,7 @@ pub type sockaddr_in6 = { a2: *u8, a3: *u8 }; #[cfg(target_arch="x86")] +#[cfg(target_arch="arm")] pub type sockaddr_in6 = { a0: *u8, a1: *u8, a2: *u8, a3: *u8, @@ -266,6 +271,7 @@ pub mod addr_in_impl { a2: *u8, a3: *u8 }; #[cfg(target_arch="x86")] +#[cfg(target_arch="arm")] pub type addr_in = { a0: *u8, a1: *u8, a2: *u8, a3: *u8, @@ -284,6 +290,7 @@ pub mod addr_in_impl { // unix size: 48, 32bit: 32 pub type addrinfo = addrinfo_impl::addrinfo; #[cfg(target_os="linux")] +#[cfg(target_os="android")] pub mod addrinfo_impl { #[cfg(target_arch="x86_64")] pub type addrinfo = { @@ -291,6 +298,7 @@ pub mod addrinfo_impl { a04: *u8, a05: *u8 }; #[cfg(target_arch="x86")] + #[cfg(target_arch="arm")] pub type addrinfo = { a00: *u8, a01: *u8, a02: *u8, a03: *u8, a04: *u8, a05: *u8, a06: *u8, a07: *u8 @@ -324,6 +332,7 @@ pub mod uv_ll_struct_stubgen { pub fn gen_stub_uv_tcp_t() -> uv_tcp_t { return gen_stub_os(); #[cfg(target_os = "linux")] + #[cfg(target_os = "android")] #[cfg(target_os = "macos")] #[cfg(target_os = "freebsd")] pub fn gen_stub_os() -> uv_tcp_t { @@ -354,6 +363,7 @@ pub mod uv_ll_struct_stubgen { }; } #[cfg(target_arch="x86")] + #[cfg(target_arch="arm")] pub fn gen_stub_arch() -> uv_tcp_t { return { fields: { loop_handle: ptr::null(), type_: 0u32, close_cb: ptr::null(), @@ -439,6 +449,7 @@ pub mod uv_ll_struct_stubgen { }; } #[cfg(target_arch = "x86")] + #[cfg(target_arch="arm")] pub fn gen_stub_arch() -> uv_async_t { return { fields: { loop_handle: ptr::null(), type_: 0u32, close_cb: ptr::null(), @@ -488,6 +499,7 @@ pub mod uv_ll_struct_stubgen { }; } #[cfg(target_arch = "x86")] + #[cfg(target_arch="arm")] pub fn gen_stub_arch() -> uv_timer_t { return { fields: { loop_handle: ptr::null(), type_: 0u32, close_cb: ptr::null(), @@ -537,6 +549,7 @@ pub mod uv_ll_struct_stubgen { }; } #[cfg(target_arch="x86")] + #[cfg(target_arch="arm")] pub fn gen_stub_arch() -> uv_write_t { return { fields: { loop_handle: ptr::null(), type_: 0u32, close_cb: ptr::null(), @@ -1548,6 +1561,7 @@ pub mod test { #[cfg(target_os="win32")] #[cfg(target_os="darwin")] #[cfg(target_os="linux")] + #[cfg(target_os="android")] pub mod tcp_and_server_client_test { #[cfg(target_arch="x86_64")] pub mod impl64 { @@ -1557,6 +1571,7 @@ pub mod test { } } #[cfg(target_arch="x86")] + #[cfg(target_arch="arm")] pub mod impl32 { #[test] #[ignore(cfg(target_os = "linux"))] diff --git a/src/rt/arch/arm/_context.S b/src/rt/arch/arm/_context.S new file mode 100644 index 0000000000000..8d370c2d64e4c --- /dev/null +++ b/src/rt/arch/arm/_context.S @@ -0,0 +1,47 @@ +.text +.code 32 +.arm +.align + + +.globl swap_registers +swap_registers: + str r0, [r0, #0] + str r3, [r0, #12] + str r4, [r0, #16] + str r5, [r0, #20] + str r6, [r0, #24] + str r7, [r0, #28] + str r8, [r0, #32] + str r9, [r0, #36] + str r10, [r0, #40] + str r11, [r0, #44] + str r12, [r0, #48] + str sp, [r0, #52] + str lr, [r0, #56] + + mrs r2, cpsr + str r2, [r0, #64] + + + ldr r0, [r1, #0] + ldr r3, [r1, #12] + ldr r4, [r1, #16] + ldr r5, [r1, #20] + ldr r6, [r1, #24] + ldr r7, [r1, #28] + ldr r8, [r1, #32] + ldr r9, [r1, #36] + ldr r10, [r1, #40] + ldr r11, [r1, #44] + ldr r12, [r1, #48] + + ldr sp, [r1, #52] + ldr lr, [r1, #56] + + ldr r2, [r1, #64] + msr cpsr_cxsf, r2 + + mov pc, lr + + diff --git a/src/rt/arch/arm/ccall.S b/src/rt/arch/arm/ccall.S new file mode 100644 index 0000000000000..4b89cc994a7a5 --- /dev/null +++ b/src/rt/arch/arm/ccall.S @@ -0,0 +1,27 @@ +.text +.code 32 +.arm +.align + +.globl __morestack +.hidden __morestack +__morestack: + mov r3, sp + mov sp, r2 + + str r3, [sp] + str lr, [sp, #-4] + + sub sp, #8 + + blx r1 + + add sp, #8 + + ldr lr, [sp, #-4] + ldr r3, [sp] + + mov sp, r3 + mov pc, lr + + diff --git a/src/rt/arch/arm/context.cpp b/src/rt/arch/arm/context.cpp new file mode 100644 index 0000000000000..dbf06a532a878 --- /dev/null +++ b/src/rt/arch/arm/context.cpp @@ -0,0 +1,36 @@ + +#include "context.h" +#include "../../rust_globals.h" + +extern "C" void CDECL swap_registers(registers_t *oregs, + registers_t *regs) +asm ("swap_registers"); + +context::context() +{ + assert((void*)®s == (void*)this); + memset(®s, 0, sizeof(regs)); +} + +void context::swap(context &out) +{ + swap_registers(&out.regs, ®s); +} + +void context::call(void *f, void *arg, void *stack) +{ + // Get the current context, which we will then modify to call the + // given function. + swap(*this); + + // set up the stack + uint32_t *sp = ( uint32_t *)stack; + //sp = align_down(sp); + // The final return address. 0 indicates the bottom of the stack + *--sp = 0; + + regs.data[0] = ( uint32_t )arg; // r0 + regs.data[13] = ( uint32_t )sp; //#52 sp, r13 + regs.data[14] = ( uint32_t )f; //#60 pc, r15 --> lr, + // Last base pointer on the stack should be 0 +} diff --git a/src/rt/arch/arm/context.h b/src/rt/arch/arm/context.h new file mode 100644 index 0000000000000..6c7db766d6a7e --- /dev/null +++ b/src/rt/arch/arm/context.h @@ -0,0 +1,43 @@ +// -*- mode: c++ -*- + +#ifndef CONTEXT_H +#define CONTEXT_H + +#include +#include +#include +//#include + +#include "vg/memcheck.h" + +template +T align_down(T sp) +{ + // There is no platform we care about that needs more than a + // 16-byte alignment. + return (T)((uint32_t)sp & ~(16 - 1)); +} + +// The struct in which we store the saved data. This is mostly the +// volatile registers and instruction pointer, but it also includes +// RCX/RDI which are used to pass arguments. The indices for each +// register are found in "regs.h". Note that the alignment must be +// 16 bytes so that SSE instructions can be used. +#include "regs.h" +struct registers_t { + uint32_t data[RUSTRT_MAX]; +} __attribute__((aligned(16))); + +class context { +public: + registers_t regs; + + context(); + + context *next; + + void swap(context &out); + void call(void *f, void *arg, void *sp); +}; + +#endif diff --git a/src/rt/arch/arm/gpr.cpp b/src/rt/arch/arm/gpr.cpp new file mode 100644 index 0000000000000..32a68d0732ab3 --- /dev/null +++ b/src/rt/arch/arm/gpr.cpp @@ -0,0 +1,15 @@ +#include "gpr.h" + +#define LOAD(rn) do { \ + uintptr_t tmp; \ + asm("mov %%" #rn ",%0" : "=r" (tmp) :); \ + this->rn = tmp; \ +} while (0) + +void rust_gpr::load() { + LOAD(r0); LOAD(r1); LOAD(r2); LOAD(r3); + LOAD(r4); LOAD(r5); LOAD(r6); LOAD(r7); + LOAD(r8); LOAD(r9); LOAD(r10); LOAD(r11); + LOAD(r12); LOAD(r13); LOAD(r14); LOAD(r15); +} + diff --git a/src/rt/arch/arm/gpr.h b/src/rt/arch/arm/gpr.h new file mode 100644 index 0000000000000..472c8a05e35e4 --- /dev/null +++ b/src/rt/arch/arm/gpr.h @@ -0,0 +1,23 @@ +// General-purpose registers. This structure is used during stack crawling. + +#ifndef GPR_H +#define GPR_H + +#include "rust_gpr_base.h" + +class rust_gpr : public rust_gpr_base { +public: + uintptr_t r0, r1, r2, r3, r4, r5, r6, r7; + uintptr_t r8, r9, r10, r11, r12, r13, r14, r15; + + inline uintptr_t get_fp() { return r11; } + inline uintptr_t get_ip() { return r12; } + + inline void set_fp(uintptr_t new_fp) { r11 = new_fp; } + inline void set_ip(uintptr_t new_ip) { r12 = new_ip; } + + void load(); +}; + +#endif + diff --git a/src/rt/arch/arm/record_sp.S b/src/rt/arch/arm/record_sp.S new file mode 100644 index 0000000000000..193104d53b11b --- /dev/null +++ b/src/rt/arch/arm/record_sp.S @@ -0,0 +1,61 @@ +.text +.code 32 +.arm +.align + + +.globl record_sp_limit +.globl get_sp_limit +.globl get_sp + +record_sp_limit: + mov r3, r0 + ldr r0, =my_cpu + mov r1, #0 + mov r2, #0 + stmfd sp!, {r3, r7} + ldr r7, =345 + swi #0 + ldmfd sp!, {r3, r7} + movs r0, r0 + movmi r0, #0 + + ldr r1, =my_array + str r3, [r1, r0] + mov pc, lr + + +get_sp_limit: + ldr r0, =my_cpu + mov r1, #0 + mov r2, #0 + stmfd sp!, {r4, r7} + ldr r7, =345 + swi #0 + ldmfd sp!, {r4, r7} + movs r0, r0 + movmi r0, #0 + mov r3, r0 + + ldr r1, =my_array + ldr r0, [r1, r3] + mov pc, lr + + +get_sp: + mov r0, sp + mov pc, lr + +.data +my_cpu: .long 0 +.global my_array +my_array: + .long 0 + .long 0 + .long 0 + .long 0 + .long 0 + .long 0 + .long 0 + .long 0 +.end diff --git a/src/rt/arch/arm/regs.h b/src/rt/arch/arm/regs.h new file mode 100644 index 0000000000000..a49fcab1184c5 --- /dev/null +++ b/src/rt/arch/arm/regs.h @@ -0,0 +1,21 @@ +#define RUSTRT_RBX 0 +#define RUSTRT_RSP 1 +#define RUSTRT_RBP 2 +// RCX on Windows, RDI elsewhere +#define RUSTRT_ARG0 3 +#define RUSTRT_R12 4 +#define RUSTRT_R13 5 +#define RUSTRT_R14 6 +#define RUSTRT_R15 7 +#define RUSTRT_IP 8 + +#define RUSTRT_MAX 32 + +// ARG0 is the register in which the first argument goes. +// Naturally this depends on your operating system. +# define RUSTRT_ARG0_S r0 +# define RUSTRT_ARG1_S r1 +# define RUSTRT_ARG2_S r2 +# define RUSTRT_ARG3_S r3 + + diff --git a/src/rt/rust_android_dummy.cpp b/src/rt/rust_android_dummy.cpp new file mode 100644 index 0000000000000..76aa51723ef32 --- /dev/null +++ b/src/rt/rust_android_dummy.cpp @@ -0,0 +1,61 @@ +// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "rust_android_dummy.h" +#include + +#ifdef __ANDROID__ + +int backtrace(void **array, int size) { return 0; } + +char **backtrace_symbols(void *const *array, int size) { return 0; } + +void backtrace_symbols_fd (void *const *array, int size, int fd) {} + + +extern "C" float log2f(float f) +{ + return logf( f ) / logf( 2 ); +} + +extern "C" double log2( double n ) +{ + return log( n ) / log( 2 ); +} + +extern "C" void telldir() +{ +} + +extern "C" void seekdir() +{ +} + +extern "C" void mkfifo() +{ +} + +extern "C" void abs() +{ +} + +extern "C" void labs() +{ +} + +extern "C" void rand() +{ +} + +extern "C" void srand() +{ +} + +extern "C" void atof() +{ +} +extern "C" void tgammaf() +{ +} +#endif diff --git a/src/rt/rust_android_dummy.h b/src/rt/rust_android_dummy.h new file mode 100644 index 0000000000000..2e8b6f2c76604 --- /dev/null +++ b/src/rt/rust_android_dummy.h @@ -0,0 +1,5 @@ +// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "execinfo.h" diff --git a/src/rt/rust_builtin.cpp b/src/rt/rust_builtin.cpp index a3c7486fa3a8c..04694171c5c1e 100644 --- a/src/rt/rust_builtin.cpp +++ b/src/rt/rust_builtin.cpp @@ -32,6 +32,27 @@ extern char **environ; #endif +#ifdef __ANDROID__ +time_t +timegm(struct tm *tm) +{ + time_t ret; + char *tz; + + tz = getenv("TZ"); + setenv("TZ", "", 1); + tzset(); + ret = mktime(tm); + if (tz) + setenv("TZ", tz, 1); + else + unsetenv("TZ"); + tzset(); + return ret; +} +#endif + + extern "C" CDECL rust_str* last_os_error() { rust_task *task = rust_get_current_task(); diff --git a/src/rt/rust_sched_loop.cpp b/src/rt/rust_sched_loop.cpp index e56ce6dd2637f..5ddfd88d4b4a7 100644 --- a/src/rt/rust_sched_loop.cpp +++ b/src/rt/rust_sched_loop.cpp @@ -28,6 +28,7 @@ rust_sched_loop::rust_sched_loop(rust_scheduler *sched, int id, bool killed) : id(id), should_exit(false), cached_c_stack(NULL), + extra_c_stack(NULL), dead_task(NULL), killed(killed), pump_signal(NULL), diff --git a/src/rt/rust_task.h b/src/rt/rust_task.h index 27694becdfbcf..20c9a48f1ddef 100644 --- a/src/rt/rust_task.h +++ b/src/rt/rust_task.h @@ -165,6 +165,9 @@ #define RED_ZONE_SIZE RZ_BSD_64 #endif #endif +#ifdef __ANDROID__ +#define RED_ZONE_SIZE RZ_MAC_32 +#endif struct rust_box; diff --git a/src/rustllvm/CMakeLists.txt b/src/rustllvm/CMakeLists.txt new file mode 100644 index 0000000000000..a9dc054126d9d --- /dev/null +++ b/src/rustllvm/CMakeLists.txt @@ -0,0 +1,119 @@ + +# llvm configurations +SET(llvmConfig + "${llvmBuildDir}/Release+Asserts/bin/llvm-config" + ) + +EXECUTE_PROCESS( + COMMAND ${llvmConfig} --bindir + OUTPUT_VARIABLE llvmBinDir + ) +EXECUTE_PROCESS( + COMMAND ${llvmConfig} --includedir + OUTPUT_VARIABLE llvmIncDir + ) +EXECUTE_PROCESS( + COMMAND ${llvmConfig} --libdir + OUTPUT_VARIABLE llvmLibDir + ) +EXECUTE_PROCESS( + COMMAND ${llvmConfig} --libs ARM x86 ipo bitreader bitwriter linker asmparser jit mcjit interpreter + OUTPUT_VARIABLE llvmLibs + ) +EXECUTE_PROCESS( + COMMAND ${llvmConfig} --cxxflags + OUTPUT_VARIABLE llvmCxxFlags + ) +EXECUTE_PROCESS( + COMMAND ${llvmConfig} --ldflags + OUTPUT_VARIABLE llvmLdFlags + ) +EXECUTE_PROCESS( + COMMAND ${llvmConfig} --host-target + OUTPUT_VARIABLE llvmHostTarget + ) +STRING(STRIP "${llvmCxxFlags}" llvmCxxFlags) +STRING(STRIP "${llvmLdFlags}" llvmLdFlags) +STRING(STRIP "${llvmLibs}" llvmLibs) +STRING(REPLACE " " ";" llvmCxxFlags "${llvmCxxFlags}") +STRING(REPLACE " " ";" llvmLdFlags "${llvmLdFlags}") +STRING(REPLACE " " ";" llvmLibs "${llvmLibs}") + +#MESSAGE(STATUS "llvmCxxFlags: ${llvmCxxFlags}") +#MESSAGE(STATUS "llvmLdFlags: ${llvmLdflags}") +#MESSAGE(STATUS "llvmLibs: ${llvmLibs}") +#MESSAGE(STATUS "llvmHostTarget: ${llvmHostTarget}") + +# rustllvm.def +SET(rustllvmDefIn ${RustRoot}/src/rustllvm/rustllvm.def.in) +SET(rustllvmDefOut ${BuildRustllvmDir}/rustllvm.${HostOsType}.def) + +doMakeDef(${HostOsType} rustllvmDef ${rustllvmDefIn} ${rustllvmDefOut}) + +SET(CXX ${${HostTriple}cxx}) + +SET(SHP ${HostSharedLibPrefix}) +SET(SHS ${HostSharedLibSuffix}) +SET(rustllvmso ${BuildRustllvmDir}/${SHP}rustllvm${SHS}) +SET(oRustWrapper ${BuildRustllvmDir}/RustWrapper.o) +SET(dRustWrapper ${BuildRustllvmDir}/RustWrapper.d) + +# rustllvm source +SET(rustllvmSrc + ${RustRoot}/src/rustllvm/RustWrapper.cpp + ) + +ADD_CUSTOM_COMMAND( + OUTPUT ${oRustWrapper} + COMMAND ${CMAKE_COMMAND} -E make_directory ${BuildRustllvmDir} + COMMAND ${CXX} ${HostCxxFlags} ${llvmCxxFlags} + -MT ${oRustWrapper} -MF ${dRustWrapper} + -c -o ${oRustWrapper} ${rustllvmSrc} + ) +ADD_CUSTOM_TARGET( + rustllvmobj + DEPENDS ${oRustWrapper} + ) + +ADD_CUSTOM_COMMAND( + OUTPUT ${rustllvmso} + COMMAND ${CMAKE_COMMAND} -E make_directory ${BuildRustllvmDir} + COMMAND ${CXX} ${HostLinkFlags} -o ${rustllvmso} + ${oRustWrapper} + ${HostDefFlags}${rustllvmDefOut} + ${llvmLdFlags} + ${HostPreLibFlags} + ${llvmLibs} + ${HostPostLibFlags} + -ldl -lm + DEPENDS ${oRustWrapper} + ${rustllvmDefOut} + ) +ADD_CUSTOM_TARGET( + rustllvm + DEPENDS ${rustllvmso} + ) +ADD_DEPENDENCIES( + rustllvm + rustllvmDef + rustllvmobj + ) + +# copy to stage 0 + +SET(outDir ${BuildStageDir}/stage0/lib/rustc/${HostTriple}/lib) +SET(rustllvmPath ${rustllvmso}) +GET_FILENAME_COMPONENT(rustllvmName ${rustllvmPath} NAME) +SET(rustllvmOut ${outDir}/${rustllvmName}) + +ADD_CUSTOM_COMMAND( + OUTPUT ${rustllvmOut} + COMMAND ${CMAKE_COMMAND} -E make_directory ${outDir} + COMMAND ${CMAKE_COMMAND} -E copy ${rustllvmPath} ${outDir} + DEPENDS rustllvm + ) +ADD_CUSTOM_TARGET( + rustllvmCopy0 + DEPENDS ${rustllvmOut} + ) + diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp index b01294062a627..3c38f3c6215d4 100644 --- a/src/rustllvm/RustWrapper.cpp +++ b/src/rustllvm/RustWrapper.cpp @@ -91,6 +91,12 @@ void LLVMInitializeX86TargetMC(); void LLVMInitializeX86AsmPrinter(); void LLVMInitializeX86AsmParser(); + +void LLVMInitializeARMTargetInfo(); +void LLVMInitializeARMTarget(); +void LLVMInitializeARMTargetMC(); +void LLVMInitializeARMAsmPrinter(); +void LLVMInitializeARMAsmParser(); // Only initialize the platforms supported by Rust here, // because using --llvm-root will have multiple platforms // that rustllvm doesn't actually link to and it's pointless to put target info @@ -102,6 +108,12 @@ void LLVMRustInitializeTargets() { LLVMInitializeX86TargetMC(); LLVMInitializeX86AsmPrinter(); LLVMInitializeX86AsmParser(); + + LLVMInitializeARMTargetInfo(); + LLVMInitializeARMTarget(); + LLVMInitializeARMTargetMC(); + LLVMInitializeARMAsmPrinter(); + LLVMInitializeARMAsmParser(); } // Custom memory manager for MCJITting. It needs special features diff --git a/src/rustllvm/rustllvm.def.in b/src/rustllvm/rustllvm.def.in index 44636f4f36b16..d3cbc490ada45 100644 --- a/src/rustllvm/rustllvm.def.in +++ b/src/rustllvm/rustllvm.def.in @@ -383,19 +383,19 @@ LLVMInitializeInstCombine LLVMInitializeScalarOpts LLVMInitializeTarget LLVMInitializeTransformUtils +LLVMInitializeARMAsmLexer LLVMInitializeX86AsmLexer -LLVMInitializeX86AsmLexer -LLVMInitializeX86AsmParser +LLVMInitializeARMAsmParser LLVMInitializeX86AsmParser +LLVMInitializeARMAsmPrinter LLVMInitializeX86AsmPrinter -LLVMInitializeX86AsmPrinter -LLVMInitializeX86Disassembler +LLVMInitializeARMDisassembler LLVMInitializeX86Disassembler +LLVMInitializeARMTarget LLVMInitializeX86Target -LLVMInitializeX86Target -LLVMInitializeX86TargetMC +LLVMInitializeARMTargetMC LLVMInitializeX86TargetMC -LLVMInitializeX86TargetInfo +LLVMInitializeARMTargetInfo LLVMInitializeX86TargetInfo LLVMInsertBasicBlock LLVMInsertBasicBlockInContext From 6fa04c23293da728f4a64415def8662a0a4dcb88 Mon Sep 17 00:00:00 2001 From: ILyoan Date: Thu, 29 Nov 2012 19:36:03 +0900 Subject: [PATCH 3/3] cmake build sciprts for rust --- CMakeLists.txt | 40 ++ Makefile.in | 2 +- README.md | 59 +++ cmakeFiles/config.cmake | 231 ++++++++++++ cmakeFiles/install.cmake | 111 ++++++ cmakeFiles/libuv.cmake | 75 ++++ cmakeFiles/llvm.cmake | 65 ++++ cmakeFiles/rt.cmake | 315 ++++++++++++++++ cmakeFiles/rustc.cmake | 250 +++++++++++++ cmakeFiles/rustctarget.cmake | 109 ++++++ .../rustllvm.cmake | 52 ++- cmakeFiles/snapshot.cmake | 26 ++ cmakeFiles/submodules.cmake | 22 ++ configure | 2 +- mk/libuv/arm/unix/android/Makefile | 354 ++++++++++++++++++ .../src/libuv/run-benchmarks.target.mk | 115 ++++++ .../android/src/libuv/run-tests.target.mk | 158 ++++++++ .../arm/unix/android/src/libuv/uv.Makefile | 6 + .../arm/unix/android/src/libuv/uv.target.mk | 184 +++++++++ src/rt/rust_android_dummy.h | 12 +- src/rt/rust_builtin.cpp | 2 +- src/rt/rust_task.cpp | 6 +- 22 files changed, 2176 insertions(+), 20 deletions(-) create mode 100644 CMakeLists.txt create mode 100644 cmakeFiles/config.cmake create mode 100644 cmakeFiles/install.cmake create mode 100644 cmakeFiles/libuv.cmake create mode 100644 cmakeFiles/llvm.cmake create mode 100644 cmakeFiles/rt.cmake create mode 100644 cmakeFiles/rustc.cmake create mode 100644 cmakeFiles/rustctarget.cmake rename src/rustllvm/CMakeLists.txt => cmakeFiles/rustllvm.cmake (66%) create mode 100644 cmakeFiles/snapshot.cmake create mode 100644 cmakeFiles/submodules.cmake create mode 100755 mk/libuv/arm/unix/android/Makefile create mode 100755 mk/libuv/arm/unix/android/src/libuv/run-benchmarks.target.mk create mode 100755 mk/libuv/arm/unix/android/src/libuv/run-tests.target.mk create mode 100755 mk/libuv/arm/unix/android/src/libuv/uv.Makefile create mode 100755 mk/libuv/arm/unix/android/src/libuv/uv.target.mk diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000000000..56762ba004423 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,40 @@ +## CMakeLists.txt +PROJECT(Rust) +CMAKE_MINIMUM_REQUIRED(VERSION 2.8) + +# The version number +SET(RustVersionMajor 0) +SET(RustVersionMinor 5) + +INCLUDE(cmakeFiles/config.cmake) +INCLUDE(cmakeFiles/submodules.cmake) +INCLUDE(cmakeFiles/snapshot.cmake) +INCLUDE(cmakeFiles/libuv.cmake) +INCLUDE(cmakeFiles/llvm.cmake) +INCLUDE(cmakeFiles/rustllvm.cmake) +INCLUDE(cmakeFiles/rt.cmake) +INCLUDE(cmakeFiles/rustc.cmake) +INCLUDE(cmakeFiles/install.cmake) +IF(${IsCrossCompile}) + INCLUDE(cmakeFiles/rustctarget.cmake) +ENDIF() + + +#SET(cmakeDir "${CMAKE_SOURCE_DIR}/cmakeFiles") +#SET(cmakeConfigure "${cmakeDir}/configuration.cmake") +#SET(cmakeSnapshot "${cmakeDir}/snapshot.cmake") +#SET(cmakeRustc "${cmakeDir}/rustc.cmake") +#SET(cmakellvm "${cmakeDir}/llvm.cmake") +#SET(cmakelibuv "${cmakeDir}/libuv.cmake") +#SET(cmakeInstall "${cmakeDir}/install.cmake") +# +#INCLUDE(${cmakeConfigure}) +#INCLUDE(${cmakeSnapshot}) +#INCLUDE(${cmakellvm}) +#INCLUDE(${cmakelibuv}) +#INCLUDE(${cmakeInstall}) +# +#ADD_SUBDIRECTORY(src) +# +#INCLUDE(${cmakeRustc}) + diff --git a/Makefile.in b/Makefile.in index 963f455fe8ab2..6b9c4615e883b 100644 --- a/Makefile.in +++ b/Makefile.in @@ -241,7 +241,7 @@ DRIVER_CRATE := $(S)src/driver/driver.rs ###################################################################### # FIXME: x86-ism -LLVM_COMPONENTS=x86 ipo bitreader bitwriter linker asmparser jit mcjit \ +LLVM_COMPONENTS=x86 ARM ipo bitreader bitwriter linker asmparser jit mcjit \ interpreter define DEF_LLVM_VARS diff --git a/README.md b/README.md index 877e2b5698722..6af46e5e65f21 100644 --- a/README.md +++ b/README.md @@ -76,3 +76,62 @@ See LICENSE-APACHE, LICENSE-MIT, and COPYRIGHT for details. The [tutorial] is a good starting point. [tutorial]: http://static.rust-lang.org/doc/tutorial.html + + +========================== Steps for Android Target addtion ======================= + +1. setup android ndk standalone tool chain with platform=14 option + + Android NDK can be downloaded from http://developer.android.com/tools/sdk/ndk/index.html + + example command to setup standalone tool chain: + + ~/work/toolchains/android-ndk-r8c/build/tools$ ./make-standalone-toolchain.sh --platform=android-14 --install-dir=/home/ubuntu/work/toolchains/ndk_standalone --ndk-dir=/home/ubuntu/work/toolchains/android-ndk-r8c + +2. Download rustc from git repository + + a. git clone http://github.com/webconv/rust.git + + b. cd rust + + c. mkdir build + + d. cd build + +3. Create Makefile using CMake + + cmake ../ -DTargetOsType=android -DTargetCpuType=arm -DToolchain=path_of_standalone_toolchain_dir + +4. Build libuv and llvm + + make libuv + + make llvm + + +5. Create Makefile again (the Makefile made in step 3 does not contain information of llvm) + + cmake ../ + +6. Build Rustc ( make and make install have been separated) + + a.make + + b.make install [ it will copy ARM libraries into /usr/local/lib/rustc/arm-unknown-android/lib + + +7. How to cross compiler + + rustc --target arm-unknown-android hello.rs + + +8. How to run on Android + + use adb -e push command to push all arm libs as specified in 6 b + + push your binary + + set LD_LIBRARY_PATH + + run using adb shell + diff --git a/cmakeFiles/config.cmake b/cmakeFiles/config.cmake new file mode 100644 index 0000000000000..7037b2f9194ed --- /dev/null +++ b/cmakeFiles/config.cmake @@ -0,0 +1,231 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.8) + + +# set host information + +SET(HostCpuType ${CMAKE_SYSTEM_PROCESSOR}) +IF(${HostCpuType} MATCHES "i386|i486|i686|i786|x86") + SET(HostCpuType "i686") + IF(APPLE) + EXECUTE_PROCESS( + COMMAND sysctl hw.optional.x86_64 + OUTPUT_VARIABLE cpucheck + ) + IF(cpucheck MATCHES ": 1") + SET(HostCpuType "x86_64") + ENDIF() + ENDIF() +ELSEIF(${HostCpuType} MATCHES "x86-64|x86_64|x64|amd64") + SET(HostCpuType "x86_64") +ELSE() + MESSAGE(FATAL_ERROR "Unkown CPU type") +ENDIF() + +IF(APPLE) + SET(HostOsType darwin) + SET(HostTriple ${HostCpuType}-apple-darwin) +ELSEIF(UNIX) + SET(HostOsType linux) + SET(HostTriple ${HostCpuType}-unknown-linux-gnu) +ELSE() + MESSAGE(FATAL_ERROR "Unknown OS") +ENDIF() + +SET(HostSharedLibPrefix ${CMAKE_SHARED_LIBRARY_PREFIX}) +SET(HostSharedLibSuffix ${CMAKE_SHARED_LIBRARY_SUFFIX}) +SET(HostStaticLibPrefix ${CMAKE_STATIC_LIBRARY_PREFIX}) +SET(HostStaticLibSuffix ${CMAKE_STATIC_LIBRARY_SUFFIX}) +SET(HostExecSuffix ${CMAKE_EXECUTABLE_SUFFIX}) + +# set target information + +IF(TargetOsType AND TargetCpuType) + IF(NOT ${TargetOsType} STREQUAL "android") + MESSAGE(FATAL_ERROR "Unknown target OS") + ENDIF() + IF(NOT ${TargetCpuType} STREQUAL "arm") + MESSAGE(FATAL_ERROR "Unknown target CPU type") + ENDIF() + + IF(${TargetOsType} STREQUAL "android") + SET(TargetTriple ${TargetCpuType}-unknown-android) + + SET(TargetSharedLibPrefix lib) + SET(TargetSharedLibSuffix .so) + SET(TargetStaticLibPrefix lib) + SET(TargetStaticLibSuffix .a) + SET(TargetExecSuffix) + ENDIF() + + SET(IsCrossCompile TRUE) + MESSAGE(STATUS "======================================================") + MESSAGE(STATUS " Cross Target: ${TargetTriple}") + MESSAGE(STATUS "======================================================") + +ELSE() + SET(IsCrossCompile FALSE) +ENDIF() + + + +# gcc setting + +# host + +SET(${HostTriple}cc ${CMAKE_C_COMPILER}) +SET(${HostTriple}cxx ${CMAKE_CXX_COMPILER}) +SET(${HostTriple}ar ${CMAKE_AR}) + +IF(${HostOsType} STREQUAL linux) + SET(HostCFlags + -DRUST_NDEBUG -MMD -MP -fPIC -O2 -Wall -Werror -g -fno-omit-frame-pointer) + SET(HostLinkFlags -shared -fPIC -ldl -lpthread -lrt -g) + IF(${HostCpuType} STREQUAL x86_64) + SET(HostCFlags ${HostCFlags} -m64) + SET(HostLinkFlags ${HostLinkFlags} -m64) + ELSE() + SET(HostCFlags ${HostCFlags} -m32) + SET(HostLinkFlags ${HostLinkFlags} -m32) + ENDIF() + SET(HostCxxFlags ${HostCFlags} -fno-rtti) + SET(HostDefFlags -Wl,--export-dynamic,--dynamic-list=) + SET(HostPreLibFlags -Wl,-whole-archive) + SET(HostPostLibFlags -Wl,-no-whole-archive -Wl,-znoexecstack) + SET(HostllvmBuildEnv CXXFLAGS=-fno-omit-frame-pointer) + SET(HostLinkPthread -lpthread) +ELSE() # darwin + SET(HostCFlags + -DRUST_NDEBUG -MMD -MP -fPIC -O2 -Wall -Werror -g) + SET(HostLinkFlags + -dynamiclib -lpthread -framework CoreServices -Wl,-no_compact_unwind) + IF(${HostCpuType} STREQUAL x86_64) + SET(HostCFlags ${HostCFlags} -m64 -arch x86_64) + SET(HostLinkFlags ${HostLinkFlags} -m64) + ELSE() + SET(HostCFlags ${HostCFlags} -m32 -arch i386) + SET(HostLinkFlags ${HostLinkFlags} -m32) + ENDIF() + SET(HostCxxFlags ${HostCFlags} -fno-rtti) + SET(HostDefFlags -Wl,-exported_symbols_list,) + SET(HostPreLibFlags) + SET(HostPostLibFlags) + SET(HostllvmBuildEnv) + SET(HostLinkPthread -lpthread) +ENDIF() + +# target + +IF(TargetOsType STREQUAL "android") + IF(NOT Toolchain) + MESSAGE(FATAL_ERROR "no toolchain information\n" + "use -DToolchain=") + ENDIF() + IF(NOT EXISTS ${Toolchain}) + MESSAGE(FATAL_ERROR "no directory - ${Toolchain}\n" + "use -DToolchain=") + ENDIF() + + SET(${TargetTriple}cc ${Toolchain}/bin/arm-linux-androideabi-gcc) + SET(${TargetTriple}cxx ${Toolchain}/bin/arm-linux-androideabi-g++) + SET(${TargetTriple}ar ${Toolchain}/bin/arm-linux-androideabi-ar) + SET(${TargetTriple}include ${Toolchain}/sysroot/usr/include) + SET(${TargetTriple}lib ${Toolchain}/sysroot/usr/lib) + SET(${TargetTriple}sysroot ${Toolchain}/sysroot) + + IF(NOT EXISTS ${${TargetTriple}cc}) + MESSAGE(FATAL_ERROR "There is no gcc compiler in ${Toolchain}/bin") + ENDIF() + IF(NOT EXISTS ${${TargetTriple}cxx}) + MESSAGE(FATAL_ERROR "There is no g++ compiler in ${Toolchain}/bin") + ENDIF() + IF(NOT EXISTS ${${TargetTriple}ar}) + MESSAGE(FATAL_ERROR "There is no ar in ${Toolchain}/bin") + ENDIF() + + MESSAGE(STATUS "Target gcc - ${${TargetTriple}cc}") + MESSAGE(STATUS "Target g++ - ${${TargetTriple}cxx}") + MESSAGE(STATUS "Target ar - ${${TargetTriple}ar}") + + SET(TargetCFlags + -DRUST_NDEBUG -MMD -MP -fPIC -O2 -Wall -g -fno-omit-frame-pointer + -D__arm__ -DANDROID -D__ANDROID__ + -I${Toolchain}/arm-linux-androideabi/include/c++/4.6 + -I${Toolchain}/arm-linux-androideabi/include/c++/4.6/arm-linux-androideabi + ) + SET(TargetLinkFlags -shared -fPIC -ldl -g -lm -lsupc++ -lgnustl_shared) + SET(TargetCxxFlags ${TargetCFlags} -fno-rtti) + SET(TargetDefFlags -Wl,--export-dynamic,--dynamic-list=) + SET(TargetPreLibFlags -Wl,-whole-archive) + SET(TargetPostLibFlags -Wl,-no-whole-archive -Wl,-znoexecstack) + SET(TargetLinkPthread) +ENDIF() + +##SET(CMAKE_C_COMPILER "gcc") +##SET(CMAKE_CXX_COMILER "g++") +#SET(CMAKE_C_FLAGS "${GCC_CFLAGS}") +#SET(CMAKE_CXX_FLAGS "${GCC_CXXFLAGS}") +#SET(CMAKE_C_LINK_FLAGS "${GCC_LINK_FLAGS}") +#SET(CMAKE_CXX_LINK_FLAGS "${GCC_LINK_FLAGS}") + + +MACRO(doMakeDef osType defName defIn defOut) + IF(${osType} MATCHES "linux|android") + ADD_CUSTOM_COMMAND( + OUTPUT ${defOut} + COMMAND ${CMAKE_COMMAND} -E copy ${defIn} ${defOut} + COMMAND echo '{' > ${defOut} + && sed 's/.$$/&\;/' ${defIn} >> ${defOut} + && echo '}\;' >> ${defOut} + DEPENDS ${defIn} + ) + ADD_CUSTOM_TARGET( + ${defName} + DEPENDS ${defOut} + ) + ELSEIF(${osType} STREQUAL darwin) + ADD_CUSTOM_COMMAND( + OUTPUT ${defOut} + COMMAND ${CMAKE_COMMAND} -E copy ${defIn} ${defOut} + COMMAND sed 's/^./_&/' ${defIn} > ${defOut} + DEPENDS ${defIn} + ) + ADD_CUSTOM_TARGET( + ${defName} + DEPENDS ${defOut} + ) + ENDIF() +ENDMACRO(doMakeDef) + + +SET(BuildParallel -j4) + + + +#directories + +SET(RustRoot "${CMAKE_SOURCE_DIR}") +MESSAGE(STATUS "Rust root: ${RustRoot}") + +SET(BuildRoot ${CMAKE_BINARY_DIR}) +SET(BuildDlDir ${BuildRoot}/dl) +SET(BuildStageDir ${BuildRoot}/stage) +SET(BuildRtDir ${BuildRoot}/rt) +SET(BuildRustllvmDir ${BuildRoot}/rustllvm) + + +SET(EnvVar + export CFG_BUILD_DIR=${BuildRoot} + export CFG_VERSION=${RustVersionMajor}.${RustVersionMinor} + export CFG_HOST_TRIPLE=${HostTriple} + export CFG_LLVM_ROOT= + export CFG_ENABLE_MINGW_CROSS= + export CFG_PREFIX=/usr/home + export CFG_LIBDIR=lib + export CFG_SRC_DIR=${RustRoot} + ) + +IF(EXISTS ${Toolchain}) + SET(EnvVar ${EnvVar} export PATH=$$PATH:${Toolchain}/bin + ) +ENDIF() + diff --git a/cmakeFiles/install.cmake b/cmakeFiles/install.cmake new file mode 100644 index 0000000000000..54c7344150bc5 --- /dev/null +++ b/cmakeFiles/install.cmake @@ -0,0 +1,111 @@ +MESSAGE(STATUS "Install prefix: ${CMAKE_INSTALL_PREFIX}") + +SET(installBin ${CMAKE_INSTALL_PREFIX}/bin) +SET(installLib ${CMAKE_INSTALL_PREFIX}/lib) +SET(Stage2Bin ${BuildStageDir}/stage2/bin) +SET(Stage2Lib ${BuildStageDir}/stage2/lib) +SET(Stage2OutLib ${Stage2Lib}/rustc/${HostTriple}/lib) +SET(installOutLib ${installLib}/rustc/${HostTriple}/lib) + +SET(SHP ${HostSharedLibPrefix}) +SET(SHS ${HostSharedLibSuffix}) +SET(STP ${HostStaticLibPrefix}) +SET(STS ${HostStaticLibSuffix}) +SET(EXS ${HostExecSuffix}) + +ADD_CUSTOM_TARGET( + hostInstall + COMMAND ${CMAKE_COMMAND} -E make_directory ${installBin} + COMMAND ${CMAKE_COMMAND} -E make_directory ${installLib} + COMMAND install -m755 + ${Stage2Bin}/rustc${EXS} + ${installBin}/rustc${EXS} + COMMAND install -m755 + ${Stage2Lib}/${SHP}rustrt${SHS} + ${installLib}/${SHP}rustrt${SHS} + COMMAND install -m755 + ${Stage2Lib}/${SHP}rustllvm${SHS} + ${installLib}/${SHP}rustllvm${SHS} + COMMAND install -m644 + `ls -drt1 ${Stage2Lib}/${SHP}core-*${SHS} | tail -1` + ${installLib} + COMMAND install -m644 + `ls -drt1 ${Stage2Lib}/${SHP}std-*${SHS} | tail -1` + ${installLib} + COMMAND install -m644 + `ls -drt1 ${Stage2Lib}/${SHP}syntax-*${SHS} | tail -1` + ${installLib} + COMMAND install -m644 + `ls -drt1 ${Stage2Lib}/${SHP}rustc-*${SHS} | tail -1` + ${installLib} + + COMMAND ${CMAKE_COMMAND} -E make_directory ${installOutLib} + COMMAND install -m755 + ${Stage2OutLib}/${SHP}rustrt${SHS} + ${installOutLib}/${SHP}rustrt${SHS} + COMMAND install -m755 + ${Stage2OutLib}/${STP}morestack${STS} + ${installOutLib}/${STP}morestack${STS} + COMMAND install -m644 + `ls -drt1 ${Stage2OutLib}/${SHP}core-*${SHS} | tail -1` + ${installOutLib} + COMMAND install -m644 + `ls -drt1 ${Stage2OutLib}/${SHP}std-*${SHS} | tail -1` + ${installOutLib} + COMMAND install -m644 + `ls -drt1 ${Stage2OutLib}/${SHP}syntax-*${SHS} | tail -1` + ${installOutLib} + COMMAND install -m644 + `ls -drt1 ${Stage2OutLib}/${SHP}rustc-*${SHS} | tail -1` + ${installOutLib} + ) +ADD_DEPENDENCIES( + hostInstall + rustall + ) + +IF(${IsCrossCompile}) + SET(installBin ${CMAKE_INSTALL_PREFIX}/bin) + SET(installLib ${CMAKE_INSTALL_PREFIX}/lib) + SET(Stage2Bin ${BuildStageDir}/stage2/bin) + SET(Stage2Lib ${BuildStageDir}/stage2/lib) + SET(Stage2OutLib ${Stage2Lib}/rustc/${TargetTriple}/lib) + SET(installOutLib ${installLib}/rustc/${TargetTriple}/lib) + + SET(SHP ${TargetSharedLibPrefix}) + SET(SHS ${TargetSharedLibSuffix}) + SET(STP ${TargetStaticLibPrefix}) + SET(STS ${TargetStaticLibSuffix}) + SET(EXS ${TargetExecSuffix}) + + ADD_CUSTOM_TARGET( + targetInstall + COMMAND ${CMAKE_COMMAND} -E make_directory ${installOutLib} + COMMAND install -m755 + ${Stage2OutLib}/${SHP}rustrt${SHS} + ${installOutLib}/${SHP}rustrt${SHS} + #COMMAND install -m755 + # ${Stage2OutLib}/${STP}morestack${STS} + # ${installOutLib}/${STP}libmorestack${STS} + COMMAND install -m644 + `ls -drt1 ${Stage2OutLib}/${SHP}core-*${SHS} | tail -1` + ${installOutLib} + COMMAND install -m644 + `ls -drt1 ${Stage2OutLib}/${SHP}std-*${SHS} | tail -1` + ${installOutLib} + ) + ADD_DEPENDENCIES( + targetInstall + rusttarget + ) +ENDIF() + + +IF(${IsCrossCompile}) + ADD_CUSTOM_TARGET(install) + ADD_DEPENDENCIES(install hostInstall targetInstall) +ELSE() + ADD_CUSTOM_TARGET(install) + ADD_DEPENDENCIES(install hostInstall) +ENDIF() + diff --git a/cmakeFiles/libuv.cmake b/cmakeFiles/libuv.cmake new file mode 100644 index 0000000000000..800f5644dac87 --- /dev/null +++ b/cmakeFiles/libuv.cmake @@ -0,0 +1,75 @@ +SET(libuvSrcDir ${RustRoot}/src/libuv) + +MACRO(doBuildLibuv triple os cpu) + + SET(${triple}libuvBuildDir ${BuildRoot}/libuv/${triple}) + + IF(${cpu} STREQUAL x86_64) + SET(${triple}libuvArch x86_64) + SET(${triple}libuvFlags -m64 -fPIC) + ELSEIF(${cpu} STREQUAL i686) + SET(${triple}libuvArch ia32) + SET(${triple}libuvFlags -m32 -fPIC) + ELSEIF(${cpu} MATCHES "arm") + SET(${triple}libuvArch arm) + SET(${triple}libuvFlags -fPIC) + ENDIF() + + IF(${os} STREQUAL darwin) + SET(${triple}libuvOsType mac) + SET(${triple}libuvLib + ${${triple}libuvBuildDir}/Release/libuv.a + ) + ELSEIF(${os} STREQUAL linux) + SET(${triple}libuvOsType unix/linux) + SET(${triple}libuvLib + ${${triple}libuvBuildDir}/Release/obj.target/src/libuv/libuv.a + ) + ELSEIF(${os} STREQUAL android) + SET(${triple}libuvOsType unix/android) + SET(${triple}libuvLib + ${${triple}libuvBuildDir}/Release/obj.target/src/libuv/libuv.a + ) + SET(${triple}libuvFlags ${${triple}libuvFlags} -DANDROID -std=gnu99) + ENDIF() + + + ADD_CUSTOM_COMMAND( + OUTPUT ${${triple}libuvLib} + COMMAND + ${CMAKE_COMMAND} -E make_directory ${${triple}libuvBuildDir} + COMMAND + make -C + ${RustRoot}/mk/libuv/${${triple}libuvArch}/${${triple}libuvOsType} + ${BuildParallel} + CFLAGS="${${triple}libuvFlags}" + LDFLAGS="${${triple}libuvFlags}" + CC="${${triple}cc}" + CXX="${${triple}cxx}" + AR="${${triple}ar}" + BUILDTYPE=Release + builddir_name="${${triple}libuvBuildDir}" + FLOCK=uv + ) + ADD_CUSTOM_TARGET( + ${triple}_libuv + DEPENDS ${${triple}libuvLib} + ) + ADD_DEPENDENCIES( + ${triple}_libuv + configureSubmodules + ) + + MESSAGE(STATUS "libuv Target: ${triple}libuv") +ENDMACRO(doBuildLibuv) + +ADD_CUSTOM_TARGET(libuv) +ADD_DEPENDENCIES(libuv ${HostTriple}_libuv) + + +doBuildLibuv(${HostTriple} ${HostOsType} ${HostCpuType}) + +IF(IsCrossCompile) + doBuildLibuv(${TargetTriple} ${TargetOsType} ${TargetCpuType}) +ENDIF() + diff --git a/cmakeFiles/llvm.cmake b/cmakeFiles/llvm.cmake new file mode 100644 index 0000000000000..0db40da3fe0a5 --- /dev/null +++ b/cmakeFiles/llvm.cmake @@ -0,0 +1,65 @@ + +SET(llvmSrcDir ${RustRoot}/src/llvm) +SET(llvmBuildDir ${BuildRoot}/llvm/${HostTriple}) +SET(llvmBuildEnv ${HostllvmBuildEnv}) + +SET(llvmTargets --enable-targets=x86,x86_64,arm) +SET(llvmBuild --build=${HostTriple}) +SET(llvmBuild --host=${HostTriple}) +SET(llvmTarget --target=${HostTriple}) +SET(llvmOpts + --enable-optimized + --disable-docs + --enable-bindings=none + --disable-threads + --disable-pthreads + ) +SET(llvmFlags + ${llvmTargets} + ${llvmOpts} + ${llvmBuild} + ${llvmHost} + ${llvmTarget} + ) + +SET(llvmCXX) +SET(llvmCC) +SET(llvmCFLAGS) +SET(llvmCXXFLAGS) +SET(llvmLDFLAGS) + +IF(${CMAKE_C_COMPILER} MATCHES clang) + SET(llvmCXX clang++) + SET(llvmCC clang) +ELSE() + SET(llvmCXX g++) + SET(llvmCC gcc) +ENDIF() + +IF(NOT ${HostCpuType} MATCHES x86_64) + SET(llvmCXX ${llvmCXX} -m32) + SET(llvmCC ${llvmCC} -m32) + SET(llvmCFLAGS ${llvmCFLAGS} -m32) + SET(llvmCXXFLAGS ${llvmCXXFLAGS} -m32) + SET(llvmLDFLAGS ${llvmLDFLAGS} -m32) +ENDIF() + +ADD_CUSTOM_TARGET( + llvm + COMMAND + ${CMAKE_COMMAND} -E make_directory ${llvmBuildDir} + COMMAND + export CXX="${llvmCXX}" + export CC="${llvmCC}" + export CFLAGS="${llvmCFLAGS}" + export CXXFLAGS="${llvmCXXFLAGS}" + export LDFLAGS="${llvmLDFLAGS}" + && cd ${llvmBuildDir} + && ${llvmSrcDir}/configure ${llvmFlags} + && make -C ${llvmBuildDir} ${llvmBuildEnv} ${BuildParallel} + COMMENT "Building llvm" + ) +ADD_DEPENDENCIES( + llvm + configureSubmodules + ) diff --git a/cmakeFiles/rt.cmake b/cmakeFiles/rt.cmake new file mode 100644 index 0000000000000..214529c8c0ac7 --- /dev/null +++ b/cmakeFiles/rt.cmake @@ -0,0 +1,315 @@ +cmake_minimum_required(VERSION 2.8) + + +SET(rtDir "${RustRoot}/src/rt") +SET(uvDir "${RustRoot}/src/libuv") + + +# llvm-mc +SET(llvm_mc "${llvmBuildDir}/Release+Asserts/bin/llvm-mc") +MESSAGE(STATUS "llvm-mc: ${llvm_mc}") + + +# build rustrt +MACRO(doBuildRustrt type) + + MESSAGE(STATUS "rustrt build script for ${type}") + + SET(osType ${${type}OsType}) + SET(cpuType ${${type}CpuType}) + SET(triple ${${type}Triple}) + + SET(SHP ${${type}SharedLibPrefix}) + SET(SHS ${${type}SharedLibSuffix}) + SET(STP ${${type}StaticLibPrefix}) + SET(STS ${${type}StaticLibSuffix}) + SET(EXS ${${type}ExecSuffix}) + + SET(CC ${${triple}cc}) + SET(CXX ${${triple}cxx}) + SET(AR ${${triple}ar}) + SET(CFlags ${${type}CFlags}) + SET(CxxFlags ${${type}CxxFlags}) + SET(LinkFlags ${${type}LinkFlags}) + SET(DefFlags ${${type}DefFlags}) + SET(PreLibFlags ${${type}PreLibFlags}) + SET(PostLibFlags ${${type}PostLibFlags}) + SET(LinkPthread ${${type}LinkPthread}) + + SET(archType ${cpuType}) + IF(${archType} STREQUAL "i686") + SET(archType i386) + ENDIF() + + MESSAGE(STATUS "rurstrt arch: ${archType}") + + # rustrt.def + SET(rustrtDefIn ${RustRoot}/src/rt/rustrt.def.in) + SET(rustrtDefOut ${BuildRtDir}/${triple}/rustrt.${osType}.def) + doMakeDef(${osType} ${triple}_rustrtDef ${rustrtDefIn} ${rustrtDefOut}) + + # source targets + SET(${triple}rtTargets "") + + # source objects + SET(${triple}rtObjects "") + + # morestack used? + IF(${cpuType} STREQUAL arm) + SET(useMorestack false) + ELSE() + SET(useMorestack true) + ENDIF() + + # assembly source files + IF(${useMorestack}) + SET(rtSS + arch/${archType}/morestack.S + arch/${archType}/_context.S + arch/${archType}/ccall.S + arch/${archType}/record_sp.S + ) + ELSE() + SET(rtSS + arch/${archType}/_context.S + arch/${archType}/ccall.S + arch/${archType}/record_sp.S + ) + ENDIF() + + # compile assembly + FOREACH(s ${rtSS}) + GET_FILENAME_COMPONENT(spath ${s} PATH) + GET_FILENAME_COMPONENT(sname ${s} NAME_WE) + + SET(ss ${rtDir}/${s}) + SET(bd ${BuildRtDir}/${triple}/${spath}) + SET(so ${bd}/${sname}.o) + SET(sd ${bd}/${sname}.d) + SET(sa ${bd}/${STP}${sname}${STS}) + IF(${cpuType} STREQUAL arm) + ADD_CUSTOM_COMMAND( + OUTPUT ${so} + COMMAND ${CMAKE_COMMAND} -E make_directory ${bd} + COMMAND ${CC} -MMD -MP -MT ${so} -MF ${sd} ${ss} -c -o ${so} + COMMAND ar rcs ${sa} ${so} + DEPENDS ${ss} + COMMENT "Building ${triple} ${sname}.S" + ) + ADD_CUSTOM_TARGET( + ${triple}_${sname} + DEPENDS ${so} + ) + ELSE() + ADD_CUSTOM_COMMAND( + OUTPUT ${so} + COMMAND ${CMAKE_COMMAND} -E make_directory ${bd} + COMMAND ${CC} -E -MMD -MP -MT ${so} -MF ${sd} ${ss} + | ${llvm_mc} -assemble -filetype=obj -triple=${triple} -o=${so} + COMMAND ar rcs ${sa} ${so} + DEPENDS ${ss} + COMMENT "Building ${triple} ${sname}.S" + ) + ADD_CUSTOM_TARGET( + ${triple}_${sname} + DEPENDS ${so} + ) + ENDIF() + + SET(${triple}rtTargets ${${triple}rtTargets} ${${triple}_${sname}}) + IF(NOT ${sname} MATCHES morestack) + SET(${triple}rtObjects ${${triple}rtObjects} ${so}) + ELSE() + SET(${triple}morestacko ${so}) + SET(${triple}morestacka ${sa}) + ENDIF() + ENDFOREACH(s) + + + # add include directories + SET(includeDir + -I${rtDir} + -I${rtDir}/isaac + -I${rtDir}/uthash + -I${rtDir}/arch/${archType} + -I${RustRoot}/src/libuv/include + ) + + # cpp source files + SET(rtCCxxSrc + sync/timer.cpp + sync/lock_and_signal.cpp + sync/rust_thread.cpp + rust.cpp + rust_builtin.cpp + rust_run_program.cpp + rust_env.cpp + rust_sched_loop.cpp + rust_sched_launcher.cpp + rust_sched_driver.cpp + rust_scheduler.cpp + rust_sched_reaper.cpp + rust_task.cpp + rust_stack.cpp + rust_port.cpp + rust_upcall.cpp + rust_uv.cpp + rust_crate_map.cpp + rust_log.cpp + rust_gc_metadata.cpp + rust_port_selector.cpp + rust_util.cpp + circular_buffer.cpp + isaac/randport.cpp + miniz.cpp + rust_kernel.cpp + rust_abi.cpp + rust_debug.cpp + memory_region.cpp + boxed_region.cpp + arch/${archType}/context.cpp + arch/${archType}/gpr.cpp + linenoise/linenoise.c + linenoise/utf8.c + rust_android_dummy.cpp + ) + + FOREACH(src ${rtCCxxSrc}) + GET_FILENAME_COMPONENT(cext ${src} EXT) + GET_FILENAME_COMPONENT(cpath ${src} PATH) + GET_FILENAME_COMPONENT(cname ${src} NAME_WE) + + SET(bd ${BuildRtDir}/${triple}/${cpath}) + SET(cs ${rtDir}/${src}) + SET(co ${bd}/${cname}.o) + SET(cd ${bd}/${cname}.d) + IF(${cext} STREQUAL ".c") + SET(_CC ${CC}) + SET(_Flags ${CFlags}) + ELSE() + SET(_CC ${CXX}) + SET(_Flags ${CxxFlags}) + ENDIF() + + ADD_CUSTOM_COMMAND( + OUTPUT ${co} + COMMAND ${CMAKE_COMMAND} -E make_directory ${bd} + COMMAND ${_CC} ${_Flags} -MT ${co} -MF ${cd} + -c -o ${co} ${includeDir} ${cs} + DEPENDS ${cs} + COMMENT "Building ${triple} ${cname}${cext}" + ) + ADD_CUSTOM_TARGET( + ${triple}_${cname} + DEPENDS ${co} + ) + + SET(${triple}rtTargets ${${triple}rtTargets} ${triple}_${cname}) + SET(${triple}rtObjects ${${triple}rtObjects} ${co}) + ENDFOREACH(src) + + SET(bd ${BuildRtDir}/${triple}) + SET(${triple}rustrtso ${BuildRtDir}/${triple}/${SHP}rustrt${SHS}) + ADD_CUSTOM_COMMAND( + OUTPUT ${${triple}rustrtso} + COMMAND ${CMAKE_COMMAND} -E make_directory ${bd} + COMMAND ${CXX} ${LinkFlags} -o ${${triple}rustrtso} + ${DefFlags}${rustrtDefOut} + ${${triple}rtObjects} + ${PostLibFlags} + ${${triple}libuvLib} + ${LinkPthread} + DEPENDS ${${triple}rtObjects} + ${rustrtDefOut} + ${${triple}libuvLib} + ) + ADD_CUSTOM_TARGET( + ${triple}_rustrt + DEPENDS ${${triple}rustrtso} ${${triple}libuvLib} + ) + ADD_DEPENDENCIES( + ${triple}_rustrt + ${${triple}rtTargets} + ${triple}_libuv + ) + + + # copy librustrt to stage0 output + SET(out0Dir ${BuildStageDir}/stage0/lib/rustc/${triple}/lib) + SET(out1Dir ${BuildStageDir}/stage1/lib/rustc/${triple}/lib) + SET(out2Dir ${BuildStageDir}/stage2/lib/rustc/${triple}/lib) + SET(${triple}rustrtOut0 ${out0Dir}/${SHP}rustrt${SHS}) + SET(${triple}rustrtOut1 ${out1Dir}/${SHP}rustrt${SHS}) + SET(${triple}rustrtOut2 ${out2Dir}/${SHP}rustrt${SHS}) + MESSAGE(STATUS "ok: ${${triple}rustrtOut0}") + + ADD_CUSTOM_COMMAND( + OUTPUT ${${triple}rustrtOut0} + ${${triple}rustrtOut1} + ${${triple}rustrtOut2} + COMMAND ${CMAKE_COMMAND} -E make_directory ${out0Dir} + COMMAND ${CMAKE_COMMAND} -E make_directory ${out1Dir} + COMMAND ${CMAKE_COMMAND} -E make_directory ${out2Dir} + COMMAND ${CMAKE_COMMAND} -E copy + ${${triple}rustrtso} ${${triple}rustrtOut0} + COMMAND ${CMAKE_COMMAND} -E copy + ${${triple}rustrtso} ${${triple}rustrtOut1} + COMMAND ${CMAKE_COMMAND} -E copy + ${${triple}rustrtso} ${${triple}rustrtOut2} + DEPENDS ${${triple}rustrtso} + ) + ADD_CUSTOM_TARGET( + ${triple}_rustrtCopy + DEPENDS + ${${triple}rustrtOut0} + ${${triple}rustrtOut1} + ${${triple}rustrtOut2} + ) + ADD_DEPENDENCIES( + ${triple}_rustrtCopy + ${triple}_rustrt + ) + + IF(${useMorestack}) + # copy libmorestack to stage0 output + SET(ss ${rtDir}/${s}) + SET(bd ${BuildRtDir}/${triple}/${spath}) + SET(so ${bd}/${sname}.o) + SET(sd ${bd}/${sname}.d) + SET(sa ${bd}/${STP}${sname}${STS}) + + SET(${triple}morestackOut0 ${out0Dir}/${STP}morestack${STS}) + SET(${triple}morestackOut1 ${out1Dir}/${STP}morestack${STS}) + SET(${triple}morestackOut2 ${out2Dir}/${STP}morestack${STS}) + + ADD_CUSTOM_COMMAND( + OUTPUT ${${triple}morestackOut0} + ${${triple}morestackOut1} + ${${triple}morestackOut2} + COMMAND ${CMAKE_COMMAND} -E make_directory ${out0Dir} + COMMAND ${CMAKE_COMMAND} -E make_directory ${out1Dir} + COMMAND ${CMAKE_COMMAND} -E make_directory ${out2Dir} + COMMAND ${CMAKE_COMMAND} -E copy + ${${triple}morestacka} ${${triple}morestackOut0} + COMMAND ${CMAKE_COMMAND} -E copy + ${${triple}morestacka} ${${triple}morestackOut1} + COMMAND ${CMAKE_COMMAND} -E copy + ${${triple}morestacka} ${${triple}morestackOut2} + DEPENDS ${${triple}morestacko} + ) + ADD_CUSTOM_TARGET( + ${triple}_morestackCopy + DEPENDS + ${${triple}morestackOut0} + ${${triple}morestackOut1} + ${${triple}morestackOut2} + ) + ENDIF() + +ENDMACRO(doBuildRustrt) + +doBuildRustrt(Host) +IF(${IsCrossCompile}) + doBuildRustrt(Target) +ENDIF() + diff --git a/cmakeFiles/rustc.cmake b/cmakeFiles/rustc.cmake new file mode 100644 index 0000000000000..653dc0ba53dd8 --- /dev/null +++ b/cmakeFiles/rustc.cmake @@ -0,0 +1,250 @@ +# rustc source file +SET(driverCrate ${RustRoot}/src/driver/driver.rs) + +# variables for rustc shared libraries +MACRO(doPrepareRustLib libname) + SET(lib${libname}Dir ${RustRoot}/src/lib${libname}) + SET(lib${libname}Crate ${lib${libname}Dir}/${libname}.rc) + SET(lib${libname}Out) + FILE(GLOB_RECURSE lib${libname}Src + ${lib${libname}Dir}/*.rs + ${lib${libname}Dir}/*.rc + ) +ENDMACRO(doPrepareRustLib) + +doPrepareRustLib(core) +doPrepareRustLib(std) +doPrepareRustLib(syntax) +doPrepareRustLib(rustc) + +SET(SHP ${HostSharedLibPrefix}) +SET(SHS ${HostSharedLibSuffix}) +SET(STP ${HostStaticLibPrefix}) +SET(STS ${HostStaticLibSuffix}) +SET(EXS ${HostExecSuffix}) + + +# build a rustc shared library +MACRO(doBuildRustLib stage libname deplib) + SET(currStageDir ${BuildStageDir}/stage${stage}) + SET(currStageBin ${currStageDir}/bin) + SET(currStageLib ${currStageDir}/lib) + SET(currStageOut ${currStageLib}/rustc/${HostTriple}) + SET(crate ${lib${libname}Crate}) + SET(srcs ${lib${libname}Src}) + + SET(rustc ${currStageBin}/rustc${EXS}) + SET(rustcFlags --cfg stage${stage} -O --target=${HostTriple}) + + SET(output ${currStageOut}/lib/${SHP}${libname}${SHS}) + SET(${HostTriple}${libname}${stage}out ${output}) + SET(depout) + IF(NOT ${deplib} STREQUAL "") + SET(depout ${${HostTriple}${deplib}${stage}out}) + ENDIF() + + ADD_CUSTOM_COMMAND( + OUTPUT ${output} + COMMAND ${CMAKE_COMMAND} -E make_directory ${currStageOut}/lib + COMMAND ${EnvVar} + && ${rustc} ${rustcFlags} -o ${output} ${crate} + && touch ${output} + DEPENDS ${srcs} + ${${HostTriple}rustrtOut${stage}} + ${${HostTriple}morestackOut${stage}} + ${${HostTriple}rustllvmOut${stage}} + ${depout} + ) + ADD_CUSTOM_TARGET( + ${HostTriple}_lib${libname}${stage} + DEPENDS ${output} + ) + +ENDMACRO(doBuildRustLib) + + +# build rustc +MACRO(doBuildRustc stage) + SET(currStageDir ${BuildStageDir}/stage${stage}) + SET(currStageBin ${currStageDir}/bin) + SET(currStageLib ${currStageDir}/lib) + SET(currStageOut ${currStageLib}/rustc/${HostTriple}) + + SET(stageBuildDir ${BuildStage${stage}Dir}) + SET(stageBuildOut ${stageBuildDir}/lib/rustc/${HostTriple}) + + SET(rustc ${currStageBin}/rustc${EXS}) + SET(rustcFlags --cfg stage${stage} -O --target=${HostTriple} --cfg rustc) + + SET(output ${currStageOut}/bin/rustc${EXS}) + + ADD_CUSTOM_COMMAND( + OUTPUT ${output} + COMMAND ${CMAKE_COMMAND} -E make_directory ${currStageOut}/bin + COMMAND ${EnvVar} + && ${rustc} ${rustcFlags} -o ${output} ${driverCrate} + && touch ${output} + DEPENDS ${srcs} + ${${HostTriple}core${stage}out} + ${${HostTriple}std${stage}out} + ${${HostTriple}syntax${stage}out} + ${${HostTriple}rustc${stage}out} + ) + ADD_CUSTOM_TARGET( + ${HostTriple}_rustc${stage} + DEPENDS ${output} + ) +ENDMACRO(doBuildRustc) + + +# build stage +MACRO(doBuildStage stage) + doBuildRustLib(${stage} core "") + doBuildRustLib(${stage} std core) + doBuildRustLib(${stage} syntax std) + doBuildRustLib(${stage} rustc syntax) + doBuildRustc(${stage}) + ADD_DEPENDENCIES(${HostTriple}_libcore${stage} + ${HostTriple}_morestackCopy + ${HostTriple}_rustrtCopy + ${HostTriple}_rustllvmCopy + ) + ADD_DEPENDENCIES(${HostTriple}_libstd${stage} ${HostTriple}_libcore${stage}) + ADD_DEPENDENCIES(${HostTriple}_libsyntax${stage} ${HostTriple}_libstd${stage}) + ADD_DEPENDENCIES(${HostTriple}_librustc${stage} ${HostTriple}_libsyntax${stage}) + ADD_DEPENDENCIES(${HostTriple}_rustc${stage} ${HostTriple}_librustc${stage}) + + ADD_CUSTOM_TARGET( + stageBuild${stage} + ) + ADD_DEPENDENCIES( + stageBuild${stage} + ${HostTriple}_libcore${stage} + ${HostTriple}_libstd${stage} + ${HostTriple}_libsyntax${stage} + ${HostTriple}_librustc${stage} + ${HostTriple}_rustc${stage} + ) + + ADD_CUSTOM_TARGET( + stageBuild${stage}back + ) + ADD_DEPENDENCIES( + stageBuild${stage}back + ${HostTriple}_libcore${stage} + ${HostTriple}_libstd${stage} + ${HostTriple}_libsyntax${stage} + ${HostTriple}_librustc${stage} + ${HostTriple}_rustc${stage} + ) +ENDMACRO(doBuildStage) + +doBuildStage(0) +doBuildStage(1) +doBuildStage(2) + +ADD_DEPENDENCIES(${HostTriple}_libcore0 snapshot) + +# copy +MACRO(doCopyStageOut stage) + MATH(EXPR prevStage ${stage}-1) + MATH(EXPR nextStage ${stage}+1) + SET(currStageDir ${BuildStageDir}/stage${stage}) + SET(currStageBin ${currStageDir}/bin) + SET(currStageLib ${currStageDir}/lib) + SET(currStageOut ${currStageDir}/lib/rustc/${HostTriple}) + SET(nextStageDir ${BuildStageDir}/stage${nextStage}) + SET(nextStageBin ${nextStageDir}/bin) + SET(nextStageLib ${nextStageDir}/lib) + SET(nextStageOut ${nextStageDir}/lib/rustc/${HostTriple}) + + ADD_CUSTOM_COMMAND( + OUTPUT + ${nextStageLib}/${SHP}core${SHS} + ${nextStageLib}/${SHP}std${SHS} + ${nextStageLib}/${SHP}syntax${SHS} + ${nextStageLib}/${SHP}rustc${SHS} + ${nextStageBin}/rustc${EXS} + COMMAND ${CMAKE_COMMAND} -E make_directory ${nextStageBin} + COMMAND ${CMAKE_COMMAND} -E make_directory ${nextStageLib} + COMMAND ${CMAKE_COMMAND} -E make_directory ${nextStageOut}/bin + COMMAND ${CMAKE_COMMAND} -E make_directory ${nextStageOut}/lib + COMMAND ${CMAKE_COMMAND} -E copy + ${currStageOut}/lib/${STP}morestack${STS} ${nextStageLib} + COMMAND ${CMAKE_COMMAND} -E copy + ${currStageOut}/lib/${SHP}rustllvm${SHS} ${nextStageLib} + COMMAND ${CMAKE_COMMAND} -E copy + ${currStageOut}/lib/${SHP}rustrt${SHS} ${nextStageLib} + COMMAND ${CMAKE_COMMAND} -E touch + ${currStageOut}/lib/${SHP}core${SHS} + COMMAND ${CMAKE_COMMAND} -E copy + ${currStageOut}/lib/${SHP}core${SHS} ${nextStageLib} + COMMAND ${CMAKE_COMMAND} -E copy + ${currStageOut}/lib/${SHP}core-*${SHS} ${nextStageLib} + COMMAND ${CMAKE_COMMAND} -E touch + ${currStageOut}/lib/${SHP}std${SHS} + COMMAND ${CMAKE_COMMAND} -E copy + ${currStageOut}/lib/${SHP}std${SHS} ${nextStageLib} + COMMAND ${CMAKE_COMMAND} -E copy + ${currStageOut}/lib/${SHP}std-*${SHS} ${nextStageLib} + COMMAND ${CMAKE_COMMAND} -E touch + ${currStageOut}/lib/${SHP}syntax${SHS} + COMMAND ${CMAKE_COMMAND} -E copy + ${currStageOut}/lib/${SHP}syntax${SHS} ${nextStageLib} + COMMAND ${CMAKE_COMMAND} -E copy + ${currStageOut}/lib/${SHP}syntax-*${SHS} ${nextStageLib} + COMMAND ${CMAKE_COMMAND} -E touch + ${currStageOut}/lib/${SHP}rustc${SHS} + COMMAND ${CMAKE_COMMAND} -E copy + ${currStageOut}/lib/${SHP}rustc${SHS} ${nextStageLib} + COMMAND ${CMAKE_COMMAND} -E copy + ${currStageOut}/lib/${SHP}rustc-*${SHS} ${nextStageLib} + COMMAND ${CMAKE_COMMAND} -E copy + ${currStageOut}/bin/rustc${EXS} ${nextStageBin} + COMMENT "copy stage${stage} to stage${nextStage}" + ) + + ADD_CUSTOM_TARGET( + stageCopy${stage} + DEPENDS + ${nextStageLib}/${SHP}core${SHS} + ${nextStageLib}/${SHP}std${SHS} + ${nextStageLib}/${SHP}syntax${SHS} + ${nextStageLib}/${SHP}rustc${SHS} + ${nextStageBin}/rustc${EXS} + ) + ADD_DEPENDENCIES(stageCopy${stage} stageBuild${stage}) + + ADD_CUSTOM_TARGET( + stageCopy${stage}back + DEPENDS + ${nextStageLib}/${SHP}core${SHS} + ${nextStageLib}/${SHP}std${SHS} + ${nextStageLib}/${SHP}syntax${SHS} + ${nextStageLib}/${SHP}rustc${SHS} + ${nextStageBin}/rustc${EXS} + ) + ADD_DEPENDENCIES(stageCopy${stage}back stageBuild${stage}back) + +ENDMACRO(doCopyStageOut) + +doCopyStageOut(0) +doCopyStageOut(1) +doCopyStageOut(2) + + +ADD_CUSTOM_TARGET(stage0) +ADD_DEPENDENCIES(stage0 stageBuild0 stageCopy0) + +ADD_CUSTOM_TARGET(stage1) +ADD_DEPENDENCIES(stage1 stageBuild1 stageCopy1) + +ADD_CUSTOM_TARGET(stage2) +ADD_DEPENDENCIES(stage2 stageBuild2 stageCopy2) + +ADD_DEPENDENCIES(stageBuild2back stageCopy1back) +ADD_DEPENDENCIES(stageBuild1back stageCopy0back) + +ADD_CUSTOM_TARGET(rustall ALL) +ADD_DEPENDENCIES(rustall stageCopy2back) + diff --git a/cmakeFiles/rustctarget.cmake b/cmakeFiles/rustctarget.cmake new file mode 100644 index 0000000000000..84236bed2fa24 --- /dev/null +++ b/cmakeFiles/rustctarget.cmake @@ -0,0 +1,109 @@ +# rustc source file +SET(driverCrate ${RustRoot}/src/driver/driver.rs) + +# variables for rustc shared libraries +MACRO(doPrepareRustLib libname) + SET(lib${libname}Dir ${RustRoot}/src/lib${libname}) + SET(lib${libname}Crate ${lib${libname}Dir}/${libname}.rc) + SET(lib${libname}Out) + FILE(GLOB_RECURSE lib${libname}Src + ${lib${libname}Dir}/*.rs + ${lib${libname}Dir}/*.rc + ) +ENDMACRO(doPrepareRustLib) + +doPrepareRustLib(core) +doPrepareRustLib(std) +#doPrepareRustLib(syntax) +#doPrepareRustLib(rustc) + +SET(SHP ${TargetSharedLibPrefix}) +SET(SHS ${TargetSharedLibSuffix}) +SET(STP ${TargetStaticLibPrefix}) +SET(STS ${TargetStaticLibSuffix}) +SET(EXS ${HostExecSuffix}) + +SET(stage0Out ${BuildStageDir}/stage0/lib/rustc/${TargetTriple}) + +# build a rustc shared library +MACRO(doBuildRustLib stage libname deplib) + SET(currStageDir ${BuildStageDir}/stage${stage}) + SET(currStageBin ${currStageDir}/bin) + SET(currStageLib ${currStageDir}/lib) + SET(currStageOut ${currStageLib}/rustc/${TargetTriple}) + SET(crate ${lib${libname}Crate}) + SET(srcs ${lib${libname}Src}) + + SET(rustc ${currStageBin}/rustc${EXS}) + SET(rustcFlags --target=${TargetTriple}) + + SET(output ${currStageOut}/lib/${SHP}${libname}${SHS}) + SET(${TargetTriple}${libname}${stage}out ${output}) + SET(depout) + IF(NOT ${deplib} STREQUAL "") + SET(depout ${${TargetTriple}${deplib}${stage}out}) + ENDIF() + + ADD_CUSTOM_COMMAND( + OUTPUT ${output} + COMMAND ${CMAKE_COMMAND} -E make_directory ${currStageOut}/lib + COMMAND ${EnvVar} + && ${rustc} ${rustcFlags} -o ${output} ${crate} + && touch ${output} + DEPENDS ${srcs} + ${${HostTriple}rustrtOut} + ${${HostTriple}morestackOut} + ${${TargetTriple}rustrtOut} + ${${TargetTriple}morestackOut} + ${rustllvmOut} + ${depout} + ) + ADD_CUSTOM_TARGET( + ${TargetTriple}_lib${libname}${stage} + DEPENDS ${output} + ) + ADD_DEPENDENCIES( + ${TargetTriple}_lib${libname}${stage} + rustall + ) + +ENDMACRO(doBuildRustLib) + +# build stage +MACRO(doBuildStage stage) + doBuildRustLib(${stage} core "") + doBuildRustLib(${stage} std core) + #doBuildRustLib(${stage} syntax std) + #doBuildRustLib(${stage} rustc syntax) + + ADD_DEPENDENCIES(${TargetTriple}_libcore${stage} + #${TargetTriple}_morestackCopy + ${TargetTriple}_rustrtCopy + ${TargetTriple}_rustllvmCopy + ) + ADD_DEPENDENCIES(${TargetTriple}_libstd${stage} + ${TargetTriple}_libcore${stage}) + #ADD_DEPENDENCIES(${TargetTriple}_libsyntax${stage} + # ${TargetTriple}_libstd${stage}) + #ADD_DEPENDENCIES(${TargetTriple}_librustc${stage} + # ${TargetTriple}_libsyntax${stage}) + + ADD_CUSTOM_TARGET( + ${TargetTriple}_stageBuild${stage} + ) + ADD_DEPENDENCIES( + ${TargetTriple}_stageBuild${stage} + ${TargetTriple}_libcore${stage} + ${TargetTriple}_libstd${stage} + #${TargetTriple}_libsyntax${stage} + #${TargetTriple}_librustc${stage} + ) +ENDMACRO(doBuildStage) + +doBuildStage(2) + + +ADD_CUSTOM_TARGET(rusttarget ALL) +ADD_DEPENDENCIES(rusttarget + ${TargetTriple}_stageBuild2 + ) diff --git a/src/rustllvm/CMakeLists.txt b/cmakeFiles/rustllvm.cmake similarity index 66% rename from src/rustllvm/CMakeLists.txt rename to cmakeFiles/rustllvm.cmake index a9dc054126d9d..10fecd8ebccb8 100644 --- a/src/rustllvm/CMakeLists.txt +++ b/cmakeFiles/rustllvm.cmake @@ -99,21 +99,43 @@ ADD_DEPENDENCIES( rustllvmobj ) -# copy to stage 0 +# copy to stage +MACRO(doCopyRustllvm triple) + SET(out0Dir ${BuildStageDir}/stage0/lib/rustc/${triple}/lib) + SET(out1Dir ${BuildStageDir}/stage1/lib/rustc/${triple}/lib) + SET(out2Dir ${BuildStageDir}/stage2/lib/rustc/${triple}/lib) -SET(outDir ${BuildStageDir}/stage0/lib/rustc/${HostTriple}/lib) -SET(rustllvmPath ${rustllvmso}) -GET_FILENAME_COMPONENT(rustllvmName ${rustllvmPath} NAME) -SET(rustllvmOut ${outDir}/${rustllvmName}) + SET(rustllvmPath ${rustllvmso}) + GET_FILENAME_COMPONENT(rustllvmName ${rustllvmPath} NAME) + SET(${triple}rustllvmOut0 ${out0Dir}/${rustllvmName}) + SET(${triple}rustllvmOut1 ${out1Dir}/${rustllvmName}) + SET(${triple}rustllvmOut2 ${out2Dir}/${rustllvmName}) -ADD_CUSTOM_COMMAND( - OUTPUT ${rustllvmOut} - COMMAND ${CMAKE_COMMAND} -E make_directory ${outDir} - COMMAND ${CMAKE_COMMAND} -E copy ${rustllvmPath} ${outDir} - DEPENDS rustllvm - ) -ADD_CUSTOM_TARGET( - rustllvmCopy0 - DEPENDS ${rustllvmOut} - ) + ADD_CUSTOM_COMMAND( + OUTPUT ${${triple}rustllvmOut0} + ${${triple}rustllvmOut1} + ${${triple}rustllvmOut2} + COMMAND ${CMAKE_COMMAND} -E make_directory ${out0Dir} + COMMAND ${CMAKE_COMMAND} -E make_directory ${out1Dir} + COMMAND ${CMAKE_COMMAND} -E make_directory ${out2Dir} + COMMAND ${CMAKE_COMMAND} -E copy + ${rustllvmPath} ${${triple}rustllvmOut0} + COMMAND ${CMAKE_COMMAND} -E copy + ${rustllvmPath} ${${triple}rustllvmOut1} + COMMAND ${CMAKE_COMMAND} -E copy + ${rustllvmPath} ${${triple}rustllvmOut2} + DEPENDS rustllvm + ) + ADD_CUSTOM_TARGET( + ${triple}_rustllvmCopy + DEPENDS + ${${triple}rustllvmOut0} + ${${triple}rustllvmOut1} + ${${triple}rustllvmOut2} + ) +ENDMACRO(doCopyRustllvm) +doCopyRustllvm(${HostTriple}) +IF(${IsCrossCompile}) + doCopyRustllvm(${TargetTriple}) +ENDIF() diff --git a/cmakeFiles/snapshot.cmake b/cmakeFiles/snapshot.cmake new file mode 100644 index 0000000000000..bbad6848c01b3 --- /dev/null +++ b/cmakeFiles/snapshot.cmake @@ -0,0 +1,26 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.8) + +# snapshot rustc binary +#SET(rustc "${BuildStage0Dir}/bin/rustc") +#SET(rustcCheck "${BuildStage0Dir}/bin/rustcCheck") + +#IF(NOT EXISTS ${rustc}) +# Get snapshot + ADD_CUSTOM_TARGET( + snapshot + COMMAND ${CMAKE_COMMAND} + -E make_directory ${BuildDlDir} + COMMAND ${CMAKE_COMMAND} + -E make_directory ${BuildRoot}/${HostTriple}/stage0/bin + COMMAND ${CMAKE_COMMAND} + -E make_directory ${BuildRoot}/${HostTriple}/stage0/lib + COMMAND export CFG_SRC_DIR=${RustRoot} + && ${RustRoot}/src/etc/get-snapshot.py ${HostTriple} + COMMAND ${CMAKE_COMMAND} + -E copy_directory + ${BuildRoot}/${HostTriple}/stage0 ${BuildStageDir}/stage0 + COMMENT "Get snapshot for ${HostTriple}" + WORKING_DIRECTORY ${BuildRoot} + ) +#ENDIF(NOT EXISTS ${rustc}) + diff --git a/cmakeFiles/submodules.cmake b/cmakeFiles/submodules.cmake new file mode 100644 index 0000000000000..3627747aab31f --- /dev/null +++ b/cmakeFiles/submodules.cmake @@ -0,0 +1,22 @@ + +# update submodules + +IF(EXISTS ${RustRoot}/.git) + FIND_PROGRAM(Git git) + MESSAGE(STATUS "Git: ${Git}") + IF(${Git} MATCHES NOTFOUND) + MESSAGE(FATAL_ERROR "require git") + ENDIF() + ADD_CUSTOM_TARGET( + configureSubmodules + COMMAND ${Git} submodule --quiet sync + COMMAND ${Git} submodule --quiet update --init + COMMAND ${Git} submodule --quiet foreach --recursive + 'if test -e .gitmodules\; then git submodule sync\; fi' + COMMAND ${Git} submodule --quiet update --init --recursive + COMMAND ${Git} submodule status --recursive + WORKING_DIRECTORY ${RustRoot} + COMMENT "Updating submodules" + ) +ENDIF() + diff --git a/configure b/configure index f2afa2d26ef8d..fc3b2c8fe686a 100755 --- a/configure +++ b/configure @@ -717,7 +717,7 @@ do then msg "configuring LLVM for $t" - LLVM_TARGETS="--enable-targets=x86,x86_64" + LLVM_TARGETS="--enable-targets=x86,x86_64,arm" LLVM_BUILD="--build=$t" LLVM_HOST="--host=$t" LLVM_TARGET="--target=$t" diff --git a/mk/libuv/arm/unix/android/Makefile b/mk/libuv/arm/unix/android/Makefile new file mode 100755 index 0000000000000..16323af2cd75c --- /dev/null +++ b/mk/libuv/arm/unix/android/Makefile @@ -0,0 +1,354 @@ +# We borrow heavily from the kernel build setup, though we are simpler since +# we don't have Kconfig tweaking settings on us. + +# The implicit make rules have it looking for RCS files, among other things. +# We instead explicitly write all the rules we care about. +# It's even quicker (saves ~200ms) to pass -r on the command line. +MAKEFLAGS=-r + +# The source directory tree. +srcdir := ../../../../.. +abs_srcdir := $(abspath $(srcdir)) + +# The name of the builddir. +builddir_name ?= out + +# The V=1 flag on command line makes us verbosely print command lines. +ifdef V + quiet= +else + quiet=quiet_ +endif + +# Specify BUILDTYPE=Release on the command line for a release build. +BUILDTYPE ?= Debug + +# Directory all our build output goes into. +# Note that this must be two directories beneath src/ for unit tests to pass, +# as they reach into the src/ directory for data with relative paths. +builddir ?= $(builddir_name)/$(BUILDTYPE) +abs_builddir := $(abspath $(builddir)) +depsdir := $(builddir)/.deps + +# Object output directory. +obj := $(builddir)/obj +abs_obj := $(abspath $(obj)) + +# We build up a list of every single one of the targets so we can slurp in the +# generated dependency rule Makefiles in one pass. +all_deps := + + + +# C++ apps need to be linked with g++. +# +# Note: flock is used to seralize linking. Linking is a memory-intensive +# process so running parallel links can often lead to thrashing. To disable +# the serialization, override LINK via an envrionment variable as follows: +# +# export LINK=g++ +# +# This will allow make to invoke N linker processes as specified in -jN. +LINK ?= flock $(builddir)/linker.lock $(CXX) + +CC.target ?= $(CC) +CFLAGS.target ?= $(CFLAGS) +CXX.target ?= $(CXX) +CXXFLAGS.target ?= $(CXXFLAGS) +LINK.target ?= $(LINK) +LDFLAGS.target ?= $(LDFLAGS) +AR.target ?= $(AR) +ARFLAGS.target ?= crsT + +# N.B.: the logic of which commands to run should match the computation done +# in gyp's make.py where ARFLAGS.host etc. is computed. +# TODO(evan): move all cross-compilation logic to gyp-time so we don't need +# to replicate this environment fallback in make as well. +CC.host ?= gcc +CFLAGS.host ?= +CXX.host ?= g++ +CXXFLAGS.host ?= +LINK.host ?= g++ +LDFLAGS.host ?= +AR.host ?= ar +ARFLAGS.host := crs + +# Define a dir function that can handle spaces. +# http://www.gnu.org/software/make/manual/make.html#Syntax-of-Functions +# "leading spaces cannot appear in the text of the first argument as written. +# These characters can be put into the argument value by variable substitution." +empty := +space := $(empty) $(empty) + +# http://stackoverflow.com/questions/1189781/using-make-dir-or-notdir-on-a-path-with-spaces +replace_spaces = $(subst $(space),?,$1) +unreplace_spaces = $(subst ?,$(space),$1) +dirx = $(call unreplace_spaces,$(dir $(call replace_spaces,$1))) + +# Flags to make gcc output dependency info. Note that you need to be +# careful here to use the flags that ccache and distcc can understand. +# We write to a dep file on the side first and then rename at the end +# so we can't end up with a broken dep file. +depfile = $(depsdir)/$(call replace_spaces,$@).d +DEPFLAGS = -MMD -MF $(depfile).raw + +# We have to fixup the deps output in a few ways. +# (1) the file output should mention the proper .o file. +# ccache or distcc lose the path to the target, so we convert a rule of +# the form: +# foobar.o: DEP1 DEP2 +# into +# path/to/foobar.o: DEP1 DEP2 +# (2) we want missing files not to cause us to fail to build. +# We want to rewrite +# foobar.o: DEP1 DEP2 \ +# DEP3 +# to +# DEP1: +# DEP2: +# DEP3: +# so if the files are missing, they're just considered phony rules. +# We have to do some pretty insane escaping to get those backslashes +# and dollar signs past make, the shell, and sed at the same time. +# Doesn't work with spaces, but that's fine: .d files have spaces in +# their names replaced with other characters. +define fixup_dep +# The depfile may not exist if the input file didn't have any #includes. +touch $(depfile).raw +# Fixup path as in (1). +sed -e "s|^$(notdir $@)|$@|" $(depfile).raw >> $(depfile) +# Add extra rules as in (2). +# We remove slashes and replace spaces with new lines; +# remove blank lines; +# delete the first line and append a colon to the remaining lines. +sed -e 's|\\||' -e 'y| |\n|' $(depfile).raw |\ + grep -v '^$$' |\ + sed -e 1d -e 's|$$|:|' \ + >> $(depfile) +rm $(depfile).raw +endef + +# Command definitions: +# - cmd_foo is the actual command to run; +# - quiet_cmd_foo is the brief-output summary of the command. + +quiet_cmd_cc = CC($(TOOLSET)) $@ +cmd_cc = $(CC.$(TOOLSET)) $(GYP_CFLAGS) $(DEPFLAGS) $(CFLAGS.$(TOOLSET)) -c -o $@ $< + +quiet_cmd_cxx = CXX($(TOOLSET)) $@ +cmd_cxx = $(CXX.$(TOOLSET)) $(GYP_CXXFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c -o $@ $< + +quiet_cmd_touch = TOUCH $@ +cmd_touch = touch $@ + +quiet_cmd_copy = COPY $@ +# send stderr to /dev/null to ignore messages when linking directories. +cmd_copy = ln -f "$<" "$@" 2>/dev/null || (rm -rf "$@" && cp -af "$<" "$@") + +quiet_cmd_alink = AR($(TOOLSET)) $@ +cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) $(ARFLAGS.$(TOOLSET)) $@ $(filter %.o,$^) + +# Due to circular dependencies between libraries :(, we wrap the +# special "figure out circular dependencies" flags around the entire +# input list during linking. +quiet_cmd_link = LINK($(TOOLSET)) $@ +cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ -Wl,--start-group $(LD_INPUTS) -Wl,--end-group $(LIBS) + +# We support two kinds of shared objects (.so): +# 1) shared_library, which is just bundling together many dependent libraries +# into a link line. +# 2) loadable_module, which is generating a module intended for dlopen(). +# +# They differ only slightly: +# In the former case, we want to package all dependent code into the .so. +# In the latter case, we want to package just the API exposed by the +# outermost module. +# This means shared_library uses --whole-archive, while loadable_module doesn't. +# (Note that --whole-archive is incompatible with the --start-group used in +# normal linking.) + +# Other shared-object link notes: +# - Set SONAME to the library filename so our binaries don't reference +# the local, absolute paths used on the link command-line. +quiet_cmd_solink = SOLINK($(TOOLSET)) $@ +cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--whole-archive $(LD_INPUTS) -Wl,--no-whole-archive $(LIBS) + +quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@ +cmd_solink_module = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--start-group $(filter-out FORCE_DO_CMD, $^) -Wl,--end-group $(LIBS) + + +# Define an escape_quotes function to escape single quotes. +# This allows us to handle quotes properly as long as we always use +# use single quotes and escape_quotes. +escape_quotes = $(subst ','\'',$(1)) +# This comment is here just to include a ' to unconfuse syntax highlighting. +# Define an escape_vars function to escape '$' variable syntax. +# This allows us to read/write command lines with shell variables (e.g. +# $LD_LIBRARY_PATH), without triggering make substitution. +escape_vars = $(subst $$,$$$$,$(1)) +# Helper that expands to a shell command to echo a string exactly as it is in +# make. This uses printf instead of echo because printf's behaviour with respect +# to escape sequences is more portable than echo's across different shells +# (e.g., dash, bash). +exact_echo = printf '%s\n' '$(call escape_quotes,$(1))' + +# Helper to compare the command we're about to run against the command +# we logged the last time we ran the command. Produces an empty +# string (false) when the commands match. +# Tricky point: Make has no string-equality test function. +# The kernel uses the following, but it seems like it would have false +# positives, where one string reordered its arguments. +# arg_check = $(strip $(filter-out $(cmd_$(1)), $(cmd_$@)) \ +# $(filter-out $(cmd_$@), $(cmd_$(1)))) +# We instead substitute each for the empty string into the other, and +# say they're equal if both substitutions produce the empty string. +# .d files contain ? instead of spaces, take that into account. +command_changed = $(or $(subst $(cmd_$(1)),,$(cmd_$(call replace_spaces,$@))),\ + $(subst $(cmd_$(call replace_spaces,$@)),,$(cmd_$(1)))) + +# Helper that is non-empty when a prerequisite changes. +# Normally make does this implicitly, but we force rules to always run +# so we can check their command lines. +# $? -- new prerequisites +# $| -- order-only dependencies +prereq_changed = $(filter-out FORCE_DO_CMD,$(filter-out $|,$?)) + +# Helper that executes all postbuilds, and deletes the output file when done +# if any of the postbuilds failed. +define do_postbuilds + @E=0;\ + for p in $(POSTBUILDS); do\ + eval $$p;\ + F=$$?;\ + if [ $$F -ne 0 ]; then\ + E=$$F;\ + fi;\ + done;\ + if [ $$E -ne 0 ]; then\ + rm -rf "$@";\ + exit $$E;\ + fi +endef + +# do_cmd: run a command via the above cmd_foo names, if necessary. +# Should always run for a given target to handle command-line changes. +# Second argument, if non-zero, makes it do asm/C/C++ dependency munging. +# Third argument, if non-zero, makes it do POSTBUILDS processing. +# Note: We intentionally do NOT call dirx for depfile, since it contains ? for +# spaces already and dirx strips the ? characters. +define do_cmd +$(if $(or $(command_changed),$(prereq_changed)), + @$(call exact_echo, $($(quiet)cmd_$(1))) + @mkdir -p "$(call dirx,$@)" "$(dir $(depfile))" + $(if $(findstring flock,$(word 1,$(cmd_$1))), + @$(cmd_$(1)) + @echo " $(quiet_cmd_$(1)): Finished", + @$(cmd_$(1)) + ) + @$(call exact_echo,$(call escape_vars,cmd_$(call replace_spaces,$@) := $(cmd_$(1)))) > $(depfile) + @$(if $(2),$(fixup_dep)) + $(if $(and $(3), $(POSTBUILDS)), + $(call do_postbuilds) + ) +) +endef + +# Declare the "all" target first so it is the default, +# even though we don't have the deps yet. +.PHONY: all +all: + +# Use FORCE_DO_CMD to force a target to run. Should be coupled with +# do_cmd. +.PHONY: FORCE_DO_CMD +FORCE_DO_CMD: + +TOOLSET := target +# Suffix rules, putting all outputs into $(obj). +$(obj).$(TOOLSET)/%.o: $(srcdir)/%.c FORCE_DO_CMD + @$(call do_cmd,cc,1) +$(obj).$(TOOLSET)/%.o: $(srcdir)/%.cc FORCE_DO_CMD + @$(call do_cmd,cxx,1) +$(obj).$(TOOLSET)/%.o: $(srcdir)/%.cpp FORCE_DO_CMD + @$(call do_cmd,cxx,1) +$(obj).$(TOOLSET)/%.o: $(srcdir)/%.cxx FORCE_DO_CMD + @$(call do_cmd,cxx,1) +$(obj).$(TOOLSET)/%.o: $(srcdir)/%.S FORCE_DO_CMD + @$(call do_cmd,cc,1) +$(obj).$(TOOLSET)/%.o: $(srcdir)/%.s FORCE_DO_CMD + @$(call do_cmd,cc,1) + +# Try building from generated source, too. +$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.c FORCE_DO_CMD + @$(call do_cmd,cc,1) +$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.cc FORCE_DO_CMD + @$(call do_cmd,cxx,1) +$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.cpp FORCE_DO_CMD + @$(call do_cmd,cxx,1) +$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.cxx FORCE_DO_CMD + @$(call do_cmd,cxx,1) +$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.S FORCE_DO_CMD + @$(call do_cmd,cc,1) +$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.s FORCE_DO_CMD + @$(call do_cmd,cc,1) + +$(obj).$(TOOLSET)/%.o: $(obj)/%.c FORCE_DO_CMD + @$(call do_cmd,cc,1) +$(obj).$(TOOLSET)/%.o: $(obj)/%.cc FORCE_DO_CMD + @$(call do_cmd,cxx,1) +$(obj).$(TOOLSET)/%.o: $(obj)/%.cpp FORCE_DO_CMD + @$(call do_cmd,cxx,1) +$(obj).$(TOOLSET)/%.o: $(obj)/%.cxx FORCE_DO_CMD + @$(call do_cmd,cxx,1) +$(obj).$(TOOLSET)/%.o: $(obj)/%.S FORCE_DO_CMD + @$(call do_cmd,cc,1) +$(obj).$(TOOLSET)/%.o: $(obj)/%.s FORCE_DO_CMD + @$(call do_cmd,cc,1) + + +ifeq ($(strip $(foreach prefix,$(NO_LOAD),\ + $(findstring $(join ^,$(prefix)),\ + $(join ^,src/libuv/run-benchmarks.target.mk)))),) + include src/libuv/run-benchmarks.target.mk +endif +ifeq ($(strip $(foreach prefix,$(NO_LOAD),\ + $(findstring $(join ^,$(prefix)),\ + $(join ^,src/libuv/run-tests.target.mk)))),) + include src/libuv/run-tests.target.mk +endif +ifeq ($(strip $(foreach prefix,$(NO_LOAD),\ + $(findstring $(join ^,$(prefix)),\ + $(join ^,src/libuv/uv.target.mk)))),) + include src/libuv/uv.target.mk +endif + +#quiet_cmd_regen_makefile = ACTION Regenerating $@ +#cmd_regen_makefile = ./src/libuv/build/gyp/gyp -fmake --ignore-environment "--toplevel-dir=." -Isrc/libuv/common.gypi "--depth=." "--generator-output=mk/libuv/arm/unix/android" "-Ddefault_configuration=Default" "-Dcomponent=static_library" "-Dlibrary=static_library" "-Dtarget_arch=arm" "-DOS=linux" src/libuv/uv.gyp +#Makefile: $(srcdir)/src/libuv/uv.gyp $(srcdir)/src/libuv/common.gypi +# $(call do_cmd,regen_makefile) + +# "all" is a concatenation of the "all" targets from all the included +# sub-makefiles. This is just here to clarify. +all: + +# Add in dependency-tracking rules. $(all_deps) is the list of every single +# target in our tree. Only consider the ones with .d (dependency) info: +d_files := $(wildcard $(foreach f,$(all_deps),$(depsdir)/$(f).d)) +ifneq ($(d_files),) + # Rather than include each individual .d file, concatenate them into a + # single file which make is able to load faster. We split this into + # commands that take 1000 files at a time to avoid overflowing the + # command line. + $(shell cat $(wordlist 1,1000,$(d_files)) > $(depsdir)/all.deps) + + ifneq ($(word 1001,$(d_files)),) + $(error Found unprocessed dependency files (gyp didn't generate enough rules!)) + endif + + # make looks for ways to re-generate included makefiles, but in our case, we + # don't have a direct way. Explicitly telling make that it has nothing to do + # for them makes it go faster. + $(depsdir)/all.deps: ; + + include $(depsdir)/all.deps +endif diff --git a/mk/libuv/arm/unix/android/src/libuv/run-benchmarks.target.mk b/mk/libuv/arm/unix/android/src/libuv/run-benchmarks.target.mk new file mode 100755 index 0000000000000..20ff9609d8fd7 --- /dev/null +++ b/mk/libuv/arm/unix/android/src/libuv/run-benchmarks.target.mk @@ -0,0 +1,115 @@ +# This file is generated by gyp; do not edit. + +TOOLSET := target +TARGET := run-benchmarks +DEFS_Debug := '-D_LARGEFILE_SOURCE' \ + '-D_FILE_OFFSET_BITS=64' \ + '-D_GNU_SOURCE' \ + '-DEIO_STACKSIZE=262144' \ + '-DDEBUG' \ + '-D_DEBUG' \ + '-DEV_VERIFY=2' + +# Flags passed to all source files. +CFLAGS_Debug := \ + -Wall \ + -ansi \ + -fvisibility=hidden \ + -g \ + -O0 + +# Flags passed to only C files. +CFLAGS_C_Debug := + +# Flags passed to only C++ files. +CFLAGS_CC_Debug := -fno-rtti \ + -fno-exceptions + +INCS_Debug := -I$(srcdir)/src/libuv/include + +DEFS_Release := '-D_LARGEFILE_SOURCE' \ + '-D_FILE_OFFSET_BITS=64' \ + '-D_GNU_SOURCE' \ + '-DEIO_STACKSIZE=262144' \ + '-DNDEBUG' + +# Flags passed to all source files. +CFLAGS_Release := \ + -Wall \ + -ansi \ + -fvisibility=hidden \ + -O3 \ + -fomit-frame-pointer \ + -fdata-sections \ + -ffunction-sections + +# Flags passed to only C files. +CFLAGS_C_Release := + +# Flags passed to only C++ files. +CFLAGS_CC_Release := -fno-rtti \ + -fno-exceptions + +INCS_Release := -I$(srcdir)/src/libuv/include + +OBJS := $(obj).target/$(TARGET)/src/libuv/test/benchmark-ares.o \ + $(obj).target/$(TARGET)/src/libuv/test/benchmark-getaddrinfo.o \ + $(obj).target/$(TARGET)/src/libuv/test/benchmark-ping-pongs.o \ + $(obj).target/$(TARGET)/src/libuv/test/benchmark-pound.o \ + $(obj).target/$(TARGET)/src/libuv/test/benchmark-pump.o \ + $(obj).target/$(TARGET)/src/libuv/test/benchmark-sizes.o \ + $(obj).target/$(TARGET)/src/libuv/test/benchmark-spawn.o \ + $(obj).target/$(TARGET)/src/libuv/test/benchmark-thread.o \ + $(obj).target/$(TARGET)/src/libuv/test/benchmark-tcp-write-batch.o \ + $(obj).target/$(TARGET)/src/libuv/test/benchmark-udp-packet-storm.o \ + $(obj).target/$(TARGET)/src/libuv/test/dns-server.o \ + $(obj).target/$(TARGET)/src/libuv/test/echo-server.o \ + $(obj).target/$(TARGET)/src/libuv/test/blackhole-server.o \ + $(obj).target/$(TARGET)/src/libuv/test/run-benchmarks.o \ + $(obj).target/$(TARGET)/src/libuv/test/runner.o \ + $(obj).target/$(TARGET)/src/libuv/test/runner-unix.o + +# Add to the list of files we specially track dependencies for. +all_deps += $(OBJS) + +# Make sure our dependencies are built before any of us. +$(OBJS): | $(obj).target/src/libuv/libuv.a + +# CFLAGS et al overrides must be target-local. +# See "Target-specific Variable Values" in the GNU Make manual. +$(OBJS): TOOLSET := $(TOOLSET) +$(OBJS): GYP_CFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) $(CFLAGS_$(BUILDTYPE)) $(CFLAGS_C_$(BUILDTYPE)) +$(OBJS): GYP_CXXFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) $(CFLAGS_$(BUILDTYPE)) $(CFLAGS_CC_$(BUILDTYPE)) + +# Suffix rules, putting all outputs into $(obj). + +$(obj).$(TOOLSET)/$(TARGET)/%.o: $(srcdir)/%.c FORCE_DO_CMD + @$(call do_cmd,cc,1) + +# Try building from generated source, too. + +$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj).$(TOOLSET)/%.c FORCE_DO_CMD + @$(call do_cmd,cc,1) + +$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj)/%.c FORCE_DO_CMD + @$(call do_cmd,cc,1) + +# End of this set of suffix rules +### Rules for final target. + +$(builddir)/run-benchmarks: GYP_LDFLAGS := $(LDFLAGS_$(BUILDTYPE)) +$(builddir)/run-benchmarks: LIBS := $(LIBS) +$(builddir)/run-benchmarks: LD_INPUTS := $(OBJS) $(obj).target/src/libuv/libuv.a +$(builddir)/run-benchmarks: TOOLSET := $(TOOLSET) +$(builddir)/run-benchmarks: $(OBJS) $(obj).target/src/libuv/libuv.a FORCE_DO_CMD + $(call do_cmd,link) + +all_deps += $(builddir)/run-benchmarks +# Add target alias +.PHONY: run-benchmarks +run-benchmarks: $(builddir)/run-benchmarks + +# Add executable to "all" target. +.PHONY: all +all: $(builddir)/run-benchmarks + diff --git a/mk/libuv/arm/unix/android/src/libuv/run-tests.target.mk b/mk/libuv/arm/unix/android/src/libuv/run-tests.target.mk new file mode 100755 index 0000000000000..c4d8c207c0884 --- /dev/null +++ b/mk/libuv/arm/unix/android/src/libuv/run-tests.target.mk @@ -0,0 +1,158 @@ +# This file is generated by gyp; do not edit. + +TOOLSET := target +TARGET := run-tests +DEFS_Debug := '-D_LARGEFILE_SOURCE' \ + '-D_FILE_OFFSET_BITS=64' \ + '-D_GNU_SOURCE' \ + '-DEIO_STACKSIZE=262144' \ + '-DDEBUG' \ + '-D_DEBUG' \ + '-DEV_VERIFY=2' + +# Flags passed to all source files. +CFLAGS_Debug := \ + -Wall \ + -ansi \ + -fvisibility=hidden \ + -g \ + -O0 + +# Flags passed to only C files. +CFLAGS_C_Debug := + +# Flags passed to only C++ files. +CFLAGS_CC_Debug := -fno-rtti \ + -fno-exceptions + +INCS_Debug := -I$(srcdir)/src/libuv/include + +DEFS_Release := '-D_LARGEFILE_SOURCE' \ + '-D_FILE_OFFSET_BITS=64' \ + '-D_GNU_SOURCE' \ + '-DEIO_STACKSIZE=262144' \ + '-DNDEBUG' + +# Flags passed to all source files. +CFLAGS_Release := \ + -Wall \ + -ansi \ + -fvisibility=hidden \ + -O3 \ + -fomit-frame-pointer \ + -fdata-sections \ + -ffunction-sections + +# Flags passed to only C files. +CFLAGS_C_Release := + +# Flags passed to only C++ files. +CFLAGS_CC_Release := -fno-rtti \ + -fno-exceptions + +INCS_Release := -I$(srcdir)/src/libuv/include + +OBJS := $(obj).target/$(TARGET)/src/libuv/test/blackhole-server.o \ + $(obj).target/$(TARGET)/src/libuv/test/echo-server.o \ + $(obj).target/$(TARGET)/src/libuv/test/run-tests.o \ + $(obj).target/$(TARGET)/src/libuv/test/runner.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-get-loadavg.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-util.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-async.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-error.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-callback-stack.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-connection-fail.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-cwd-and-chdir.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-delayed-accept.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-eio-overflow.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-fail-always.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-fs.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-fs-event.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-get-currentexe.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-get-memory.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-getaddrinfo.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-gethostbyname.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-getsockname.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-hrtime.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-idle.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-ipc.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-ipc-threads.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-loop-handles.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-multiple-listen.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-pass-always.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-ping-pong.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-pipe-bind-error.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-pipe-connect-error.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-platform-output.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-process-title.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-ref.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-shutdown-eof.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-spawn.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-stdio-over-pipes.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-tcp-bind-error.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-tcp-bind6-error.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-tcp-close.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-tcp-flags.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-tcp-connect-error.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-tcp-connect6-error.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-tcp-write-error.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-tcp-write-to-half-open-connection.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-tcp-writealot.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-threadpool.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-mutexes.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-thread.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-timer-again.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-timer.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-tty.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-udp-dgram-too-big.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-udp-ipv6.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-udp-options.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-udp-send-and-recv.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-udp-multicast-join.o \ + $(obj).target/$(TARGET)/src/libuv/test/test-counters-init.o \ + $(obj).target/$(TARGET)/src/libuv/test/runner-unix.o + +# Add to the list of files we specially track dependencies for. +all_deps += $(OBJS) + +# Make sure our dependencies are built before any of us. +$(OBJS): | $(obj).target/src/libuv/libuv.a + +# CFLAGS et al overrides must be target-local. +# See "Target-specific Variable Values" in the GNU Make manual. +$(OBJS): TOOLSET := $(TOOLSET) +$(OBJS): GYP_CFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) $(CFLAGS_$(BUILDTYPE)) $(CFLAGS_C_$(BUILDTYPE)) +$(OBJS): GYP_CXXFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) $(CFLAGS_$(BUILDTYPE)) $(CFLAGS_CC_$(BUILDTYPE)) + +# Suffix rules, putting all outputs into $(obj). + +$(obj).$(TOOLSET)/$(TARGET)/%.o: $(srcdir)/%.c FORCE_DO_CMD + @$(call do_cmd,cc,1) + +# Try building from generated source, too. + +$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj).$(TOOLSET)/%.c FORCE_DO_CMD + @$(call do_cmd,cc,1) + +$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj)/%.c FORCE_DO_CMD + @$(call do_cmd,cc,1) + +# End of this set of suffix rules +### Rules for final target. + +$(builddir)/run-tests: GYP_LDFLAGS := $(LDFLAGS_$(BUILDTYPE)) +$(builddir)/run-tests: LIBS := $(LIBS) +$(builddir)/run-tests: LD_INPUTS := $(OBJS) $(obj).target/src/libuv/libuv.a +$(builddir)/run-tests: TOOLSET := $(TOOLSET) +$(builddir)/run-tests: $(OBJS) $(obj).target/src/libuv/libuv.a FORCE_DO_CMD + $(call do_cmd,link) + +all_deps += $(builddir)/run-tests +# Add target alias +.PHONY: run-tests +run-tests: $(builddir)/run-tests + +# Add executable to "all" target. +.PHONY: all +all: $(builddir)/run-tests + diff --git a/mk/libuv/arm/unix/android/src/libuv/uv.Makefile b/mk/libuv/arm/unix/android/src/libuv/uv.Makefile new file mode 100755 index 0000000000000..ba3abfe493648 --- /dev/null +++ b/mk/libuv/arm/unix/android/src/libuv/uv.Makefile @@ -0,0 +1,6 @@ +# This file is generated by gyp; do not edit. + +export builddir_name ?= mk/libuv/arm/unix/android/./src/libuv/out +.PHONY: all +all: + $(MAKE) -C ../.. uv run-benchmarks run-tests diff --git a/mk/libuv/arm/unix/android/src/libuv/uv.target.mk b/mk/libuv/arm/unix/android/src/libuv/uv.target.mk new file mode 100755 index 0000000000000..2c23caef29ccb --- /dev/null +++ b/mk/libuv/arm/unix/android/src/libuv/uv.target.mk @@ -0,0 +1,184 @@ +# This file is generated by gyp; do not edit. + +TOOLSET := target +TARGET := uv +DEFS_Debug := '-D_LARGEFILE_SOURCE' \ + '-D_FILE_OFFSET_BITS=64' \ + '-D_GNU_SOURCE' \ + '-DEIO_STACKSIZE=262144' \ + '-DHAVE_CONFIG_H' \ + '-DEV_CONFIG_H="config_android.h"' \ + '-DEIO_CONFIG_H="config_android.h"' \ + '-DDEBUG' \ + '-D_DEBUG' \ + '-DEV_VERIFY=2' + +# Flags passed to all source files. +CFLAGS_Debug := \ + -Wall \ + -ansi \ + -fvisibility=hidden \ + -g \ + --std=gnu89 \ + -pedantic \ + -Wall \ + -Wextra \ + -Wno-unused-parameter \ + -g \ + -O0 + +# Flags passed to only C files. +CFLAGS_C_Debug := + +# Flags passed to only C++ files. +CFLAGS_CC_Debug := -fno-rtti \ + -fno-exceptions + +INCS_Debug := -I$(srcdir)/src/libuv/include \ + -I$(srcdir)/src/libuv/include/uv-private \ + -I$(srcdir)/src/libuv/src \ + -I$(srcdir)/src/libuv/src/unix/ev \ + -I$(srcdir)/src/libuv/src/ares/config_android + +DEFS_Release := '-D_LARGEFILE_SOURCE' \ + '-D_FILE_OFFSET_BITS=64' \ + '-D_GNU_SOURCE' \ + '-DEIO_STACKSIZE=262144' \ + '-DHAVE_CONFIG_H' \ + '-DEV_CONFIG_H="config_android.h"' \ + '-DEIO_CONFIG_H="config_android.h"' \ + '-DNDEBUG' + +# Flags passed to all source files. +CFLAGS_Release := \ + -Wall \ + -ansi \ + -fvisibility=hidden \ + -g \ + --std=gnu89 \ + -pedantic \ + -Wall \ + -Wextra \ + -Wno-unused-parameter \ + -O3 \ + -fomit-frame-pointer \ + -fdata-sections \ + -ffunction-sections + +# Flags passed to only C files. +CFLAGS_C_Release := + +# Flags passed to only C++ files. +CFLAGS_CC_Release := -fno-rtti \ + -fno-exceptions + +INCS_Release := -I$(srcdir)/src/libuv/include \ + -I$(srcdir)/src/libuv/include/uv-private \ + -I$(srcdir)/src/libuv/src \ + -I$(srcdir)/src/libuv/src/unix/ev \ + -I$(srcdir)/src/libuv/src/ares/config_android + +OBJS := $(obj).target/$(TARGET)/src/libuv/src/uv-common.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_cancel.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares__close_sockets.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_data.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_destroy.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_expand_name.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_expand_string.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_fds.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_free_hostent.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_free_string.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_gethostbyaddr.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_gethostbyname.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares__get_hostent.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_getnameinfo.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_getopt.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_getsock.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_init.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_library_init.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_llist.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_mkquery.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_nowarn.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_options.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_parse_aaaa_reply.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_parse_a_reply.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_parse_mx_reply.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_parse_ns_reply.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_parse_ptr_reply.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_parse_srv_reply.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_parse_txt_reply.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_process.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_query.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares__read_line.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_search.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_send.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_strcasecmp.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_strdup.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_strerror.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_timeout.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares__timeval.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_version.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/ares_writev.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/bitncmp.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/inet_net_pton.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/inet_ntop.o \ + $(obj).target/$(TARGET)/src/libuv/src/ares/windows_port.o \ + $(obj).target/$(TARGET)/src/libuv/src/unix/core.o \ + $(obj).target/$(TARGET)/src/libuv/src/unix/uv-eio.o \ + $(obj).target/$(TARGET)/src/libuv/src/unix/fs.o \ + $(obj).target/$(TARGET)/src/libuv/src/unix/udp.o \ + $(obj).target/$(TARGET)/src/libuv/src/unix/tcp.o \ + $(obj).target/$(TARGET)/src/libuv/src/unix/pipe.o \ + $(obj).target/$(TARGET)/src/libuv/src/unix/tty.o \ + $(obj).target/$(TARGET)/src/libuv/src/unix/stream.o \ + $(obj).target/$(TARGET)/src/libuv/src/unix/cares.o \ + $(obj).target/$(TARGET)/src/libuv/src/unix/dl.o \ + $(obj).target/$(TARGET)/src/libuv/src/unix/error.o \ + $(obj).target/$(TARGET)/src/libuv/src/unix/thread.o \ + $(obj).target/$(TARGET)/src/libuv/src/unix/process.o \ + $(obj).target/$(TARGET)/src/libuv/src/unix/eio/eio.o \ + $(obj).target/$(TARGET)/src/libuv/src/unix/ev/ev.o \ + $(obj).target/$(TARGET)/src/libuv/src/unix/linux.o + +# Add to the list of files we specially track dependencies for. +all_deps += $(OBJS) + +# CFLAGS et al overrides must be target-local. +# See "Target-specific Variable Values" in the GNU Make manual. +$(OBJS): TOOLSET := $(TOOLSET) +$(OBJS): GYP_CFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) $(CFLAGS_$(BUILDTYPE)) $(CFLAGS_C_$(BUILDTYPE)) +$(OBJS): GYP_CXXFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) $(CFLAGS_$(BUILDTYPE)) $(CFLAGS_CC_$(BUILDTYPE)) + +# Suffix rules, putting all outputs into $(obj). + +$(obj).$(TOOLSET)/$(TARGET)/%.o: $(srcdir)/%.c FORCE_DO_CMD + @$(call do_cmd,cc,1) + +# Try building from generated source, too. + +$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj).$(TOOLSET)/%.c FORCE_DO_CMD + @$(call do_cmd,cc,1) + +$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj)/%.c FORCE_DO_CMD + @$(call do_cmd,cc,1) + +# End of this set of suffix rules +### Rules for final target. + +LIBS := -lm + +$(obj).target/src/libuv/libuv.a: GYP_LDFLAGS := $(LDFLAGS_$(BUILDTYPE)) +$(obj).target/src/libuv/libuv.a: LIBS := $(LIBS) +$(obj).target/src/libuv/libuv.a: TOOLSET := $(TOOLSET) +$(obj).target/src/libuv/libuv.a: $(OBJS) FORCE_DO_CMD + $(call do_cmd,alink) + +all_deps += $(obj).target/src/libuv/libuv.a +# Add target alias +.PHONY: uv +uv: $(obj).target/src/libuv/libuv.a + +# Add target alias to "all" target. +.PHONY: all +all: uv + diff --git a/src/rt/rust_android_dummy.h b/src/rt/rust_android_dummy.h index 2e8b6f2c76604..95a1774894bc5 100644 --- a/src/rt/rust_android_dummy.h +++ b/src/rt/rust_android_dummy.h @@ -2,4 +2,14 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "execinfo.h" +#ifndef _RUST_ANDROID_DUMMY_H +#define _RUST_ANDROID_DUMMY_H + +int backtrace (void **__array, int __size); + +char **backtrace_symbols (void *__const *__array, int __size); + +void backtrace_symbols_fd (void *__const *__array, int __size, int __fd); + +#endif + diff --git a/src/rt/rust_builtin.cpp b/src/rt/rust_builtin.cpp index 04694171c5c1e..55fb5ceb13990 100644 --- a/src/rt/rust_builtin.cpp +++ b/src/rt/rust_builtin.cpp @@ -72,7 +72,7 @@ last_os_error() { task->fail(); return NULL; } -#elif defined(_GNU_SOURCE) +#elif defined(_GNU_SOURCE) && !defined(__ANDROID__) char cbuf[BUF_BYTES]; char *buf = strerror_r(errno, cbuf, sizeof(cbuf)); if (!buf) { diff --git a/src/rt/rust_task.cpp b/src/rt/rust_task.cpp index 9dd7c62f86743..059085865d99f 100644 --- a/src/rt/rust_task.cpp +++ b/src/rt/rust_task.cpp @@ -9,9 +9,13 @@ // except according to those terms. -#ifndef __WIN32__ +#ifndef __WIN32_ +#ifdef __ANDROID__ +#include "rust_android_dummy.h" +#else #include #endif +#endif #include #include