use libc::{c_int, c_uint, c_char}; use driver::session; use session::session; use lib::llvm::llvm; use syntax::attr; use middle::ty; use metadata::{encoder, cstore}; use middle::trans::common::crate_ctxt; use metadata::common::link_meta; use std::map::HashMap; use std::sha1::sha1; use syntax::ast; use syntax::print::pprust; use lib::llvm::{ModuleRef, mk_pass_manager, mk_target_data, True, False, PassManagerRef, FileType}; use metadata::filesearch; use syntax::ast_map::{path, path_mod, path_name}; use io::{Writer, WriterUtil}; enum output_type { output_type_none, output_type_bitcode, output_type_assembly, output_type_llvm_assembly, output_type_object, output_type_exe, } impl output_type : cmp::Eq { pure fn eq(other: &output_type) -> bool { (self as uint) == ((*other) as uint) } pure fn ne(other: &output_type) -> bool { !self.eq(other) } } fn llvm_err(sess: session, msg: ~str) -> ! unsafe { let cstr = llvm::LLVMRustGetLastError(); if cstr == ptr::null() { sess.fatal(msg); } else { sess.fatal(msg + ~": " + str::raw::from_c_str(cstr)); } } fn WriteOutputFile(sess:session, PM: lib::llvm::PassManagerRef, M: ModuleRef, Triple: *c_char, // FIXME: When #2334 is fixed, change // c_uint to FileType Output: *c_char, FileType: c_uint, OptLevel: c_int, EnableSegmentedStacks: bool) { let result = llvm::LLVMRustWriteOutputFile( PM, M, Triple, Output, FileType, OptLevel, EnableSegmentedStacks); if (!result) { llvm_err(sess, ~"Could not write output"); } } mod jit { #[legacy_exports]; #[nolink] #[abi = "rust-intrinsic"] extern mod rusti { #[legacy_exports]; fn morestack_addr() -> *(); } struct Closure { code: *(), env: *(), } fn exec(sess: session, pm: PassManagerRef, m: ModuleRef, opt: c_int, stacks: bool) unsafe { let manager = llvm::LLVMRustPrepareJIT(rusti::morestack_addr()); // We need to tell JIT where to resolve all linked // symbols from. The equivalent of -lstd, -lcore, etc. // By default the JIT will resolve symbols from the std and // core linked into rustc. We don't want that, // incase the user wants to use an older std library. let cstore = sess.cstore; for cstore::get_used_crate_files(cstore).each |cratepath| { let path = cratepath.to_str(); debug!("linking: %s", path); let _: () = str::as_c_str( path, |buf_t| { if !llvm::LLVMRustLoadCrate(manager, buf_t) { llvm_err(sess, ~"Could not link"); } debug!("linked: %s", path); }); } // The execute function will return a void pointer // to the _rust_main function. We can do closure // magic here to turn it straight into a callable rust // closure. It will also cleanup the memory manager // for us. let entry = llvm::LLVMRustExecuteJIT(manager, pm, m, opt, stacks); if ptr::is_null(entry) { llvm_err(sess, ~"Could not JIT"); } else { let closure = Closure { code: entry, env: ptr::null() }; let func: fn(++argv: ~[~str]) = cast::transmute(move closure); func(~[sess.opts.binary]); } } } mod write { #[legacy_exports]; fn is_object_or_assembly_or_exe(ot: output_type) -> bool { if ot == output_type_assembly || ot == output_type_object || ot == output_type_exe { return true; } return false; } fn run_passes(sess: session, llmod: ModuleRef, output: &Path) { let opts = sess.opts; if sess.time_llvm_passes() { llvm::LLVMRustEnableTimePasses(); } let mut pm = mk_pass_manager(); let td = mk_target_data( sess.targ_cfg.target_strs.data_layout); llvm::LLVMAddTargetData(td.lltd, pm.llpm); // FIXME (#2812): run the linter here also, once there are llvm-c // bindings for it. // Generate a pre-optimization intermediate file if -save-temps was // specified. if opts.save_temps { match opts.output_type { output_type_bitcode => { if opts.optimize != session::No { let filename = output.with_filetype("no-opt.bc"); str::as_c_str(filename.to_str(), |buf| { llvm::LLVMWriteBitcodeToFile(llmod, buf) }); } } _ => { let filename = output.with_filetype("bc"); str::as_c_str(filename.to_str(), |buf| { llvm::LLVMWriteBitcodeToFile(llmod, buf) }); } } } if !sess.no_verify() { llvm::LLVMAddVerifierPass(pm.llpm); } // FIXME (#2396): This is mostly a copy of the bits of opt's -O2 that // are available in the C api. // Also: We might want to add optimization levels like -O1, -O2, // -Os, etc // Also: Should we expose and use the pass lists used by the opt // tool? if opts.optimize != session::No { let fpm = mk_pass_manager(); llvm::LLVMAddTargetData(td.lltd, fpm.llpm); let FPMB = llvm::LLVMPassManagerBuilderCreate(); llvm::LLVMPassManagerBuilderSetOptLevel(FPMB, 2u as c_uint); llvm::LLVMPassManagerBuilderPopulateFunctionPassManager(FPMB, fpm.llpm); llvm::LLVMPassManagerBuilderDispose(FPMB); llvm::LLVMRunPassManager(fpm.llpm, llmod); let mut threshold = 225; if opts.optimize == session::Aggressive { threshold = 275; } let MPMB = llvm::LLVMPassManagerBuilderCreate(); llvm::LLVMPassManagerBuilderSetOptLevel(MPMB, opts.optimize as c_uint); llvm::LLVMPassManagerBuilderSetSizeLevel(MPMB, False); llvm::LLVMPassManagerBuilderSetDisableUnitAtATime(MPMB, False); llvm::LLVMPassManagerBuilderSetDisableUnrollLoops(MPMB, False); llvm::LLVMPassManagerBuilderSetDisableSimplifyLibCalls(MPMB, False); if threshold != 0u { llvm::LLVMPassManagerBuilderUseInlinerWithThreshold (MPMB, threshold as c_uint); } llvm::LLVMPassManagerBuilderPopulateModulePassManager(MPMB, pm.llpm); llvm::LLVMPassManagerBuilderDispose(MPMB); } if !sess.no_verify() { llvm::LLVMAddVerifierPass(pm.llpm); } if is_object_or_assembly_or_exe(opts.output_type) || opts.jit { let LLVMOptNone = 0 as c_int; // -O0 let LLVMOptLess = 1 as c_int; // -O1 let LLVMOptDefault = 2 as c_int; // -O2, -Os let LLVMOptAggressive = 3 as c_int; // -O3 let mut CodeGenOptLevel = match opts.optimize { session::No => LLVMOptNone, session::Less => LLVMOptLess, session::Default => LLVMOptDefault, session::Aggressive => LLVMOptAggressive }; if opts.jit { // If we are using JIT, go ahead and create and // execute the engine now. // JIT execution takes ownership of the module, // so don't dispose and return. jit::exec(sess, pm.llpm, llmod, CodeGenOptLevel, true); if sess.time_llvm_passes() { llvm::LLVMRustPrintPassTimings(); } return; } let mut FileType; if opts.output_type == output_type_object || opts.output_type == output_type_exe { FileType = lib::llvm::ObjectFile; } else { FileType = lib::llvm::AssemblyFile; } // Write optimized bitcode if --save-temps was on. if opts.save_temps { // Always output the bitcode file with --save-temps let filename = output.with_filetype("opt.bc"); llvm::LLVMRunPassManager(pm.llpm, llmod); str::as_c_str(filename.to_str(), |buf| { llvm::LLVMWriteBitcodeToFile(llmod, buf) }); pm = mk_pass_manager(); // Save the assembly file if -S is used if opts.output_type == output_type_assembly { let _: () = str::as_c_str( sess.targ_cfg.target_strs.target_triple, |buf_t| { str::as_c_str(output.to_str(), |buf_o| { WriteOutputFile( sess, pm.llpm, llmod, buf_t, buf_o, lib::llvm::AssemblyFile as c_uint, CodeGenOptLevel, true) }) }); } // Save the object file for -c or --save-temps alone // This .o is needed when an exe is built if opts.output_type == output_type_object || opts.output_type == output_type_exe { let _: () = str::as_c_str( sess.targ_cfg.target_strs.target_triple, |buf_t| { str::as_c_str(output.to_str(), |buf_o| { WriteOutputFile( sess, pm.llpm, llmod, buf_t, buf_o, lib::llvm::ObjectFile as c_uint, CodeGenOptLevel, true) }) }); } } else { // If we aren't saving temps then just output the file // type corresponding to the '-c' or '-S' flag used let _: () = str::as_c_str( sess.targ_cfg.target_strs.target_triple, |buf_t| { str::as_c_str(output.to_str(), |buf_o| { WriteOutputFile( sess, pm.llpm, llmod, buf_t, buf_o, FileType as c_uint, CodeGenOptLevel, true) }) }); } // Clean up and return llvm::LLVMDisposeModule(llmod); if sess.time_llvm_passes() { llvm::LLVMRustPrintPassTimings(); } return; } if opts.output_type == output_type_llvm_assembly { // Given options "-S --emit-llvm": output LLVM assembly str::as_c_str(output.to_str(), |buf_o| { llvm::LLVMRustAddPrintModulePass(pm.llpm, llmod, buf_o)}); } else { // If only a bitcode file is asked for by using the '--emit-llvm' // flag, then output it here llvm::LLVMRunPassManager(pm.llpm, llmod); str::as_c_str(output.to_str(), |buf| llvm::LLVMWriteBitcodeToFile(llmod, buf) ); } llvm::LLVMDisposeModule(llmod); if sess.time_llvm_passes() { llvm::LLVMRustPrintPassTimings(); } } } /* * Name mangling and its relationship to metadata. This is complex. Read * carefully. * * The semantic model of Rust linkage is, broadly, that "there's no global * namespace" between crates. Our aim is to preserve the illusion of this * model despite the fact that it's not *quite* possible to implement on * modern linkers. We initially didn't use system linkers at all, but have * been convinced of their utility. * * There are a few issues to handle: * * - Linkers operate on a flat namespace, so we have to flatten names. * We do this using the C++ namespace-mangling technique. Foo::bar * symbols and such. * * - Symbols with the same name but different types need to get different * linkage-names. We do this by hashing a string-encoding of the type into * a fixed-size (currently 16-byte hex) cryptographic hash function (CHF: * we use SHA1) to "prevent collisions". This is not airtight but 16 hex * digits on uniform probability means you're going to need 2**32 same-name * symbols in the same process before you're even hitting birthday-paradox * collision probability. * * - Symbols in different crates but with same names "within" the crate need * to get different linkage-names. * * So here is what we do: * * - Separate the meta tags into two sets: exported and local. Only work with * the exported ones when considering linkage. * * - Consider two exported tags as special (and mandatory): name and vers. * Every crate gets them; if it doesn't name them explicitly we infer them * as basename(crate) and "0.1", respectively. Call these CNAME, CVERS. * * - Define CMETA as all the non-name, non-vers exported meta tags in the * crate (in sorted order). * * - Define CMH as hash(CMETA + hashes of dependent crates). * * - Compile our crate to lib CNAME-CMH-CVERS.so * * - Define STH(sym) as hash(CNAME, CMH, type_str(sym)) * * - Suffix a mangled sym with ::STH@CVERS, so that it is unique in the * name, non-name metadata, and type sense, and versioned in the way * system linkers understand. * */ fn build_link_meta(sess: session, c: ast::crate, output: &Path, symbol_hasher: &hash::State) -> link_meta { type provided_metas = {name: Option<~str>, vers: Option<~str>, cmh_items: ~[@ast::meta_item]}; fn provided_link_metas(sess: session, c: ast::crate) -> provided_metas { let mut name: Option<~str> = None; let mut vers: Option<~str> = None; let mut cmh_items: ~[@ast::meta_item] = ~[]; let linkage_metas = attr::find_linkage_metas(c.node.attrs); attr::require_unique_names(sess.diagnostic(), linkage_metas); for linkage_metas.each |meta| { if attr::get_meta_item_name(*meta) == ~"name" { match attr::get_meta_item_value_str(*meta) { Some(v) => { name = Some(v); } None => cmh_items.push(*meta) } } else if attr::get_meta_item_name(*meta) == ~"vers" { match attr::get_meta_item_value_str(*meta) { Some(v) => { vers = Some(v); } None => cmh_items.push(*meta) } } else { cmh_items.push(*meta); } } return {name: name, vers: vers, cmh_items: cmh_items}; } // This calculates CMH as defined above fn crate_meta_extras_hash(symbol_hasher: &hash::State, _crate: ast::crate, metas: provided_metas, dep_hashes: ~[~str]) -> ~str { fn len_and_str(s: ~str) -> ~str { return fmt!("%u_%s", str::len(s), s); } fn len_and_str_lit(l: ast::lit) -> ~str { return len_and_str(pprust::lit_to_str(@l)); } let cmh_items = attr::sort_meta_items(metas.cmh_items); symbol_hasher.reset(); for cmh_items.each |m| { match m.node { ast::meta_name_value(key, value) => { symbol_hasher.write_str(len_and_str(key)); symbol_hasher.write_str(len_and_str_lit(value)); } ast::meta_word(name) => { symbol_hasher.write_str(len_and_str(name)); } ast::meta_list(_, _) => { // FIXME (#607): Implement this fail ~"unimplemented meta_item variant"; } } } for dep_hashes.each |dh| { symbol_hasher.write_str(len_and_str(*dh)); } return truncated_hash_result(symbol_hasher); } fn warn_missing(sess: session, name: ~str, default: ~str) { if !sess.building_library { return; } sess.warn(fmt!("missing crate link meta `%s`, using `%s` as default", name, default)); } fn crate_meta_name(sess: session, _crate: ast::crate, output: &Path, metas: provided_metas) -> ~str { return match metas.name { Some(v) => v, None => { let name = match output.filestem() { None => sess.fatal(fmt!("output file name `%s` doesn't\ appear to have a stem", output.to_str())), Some(s) => s }; warn_missing(sess, ~"name", name); name } }; } fn crate_meta_vers(sess: session, _crate: ast::crate, metas: provided_metas) -> ~str { return match metas.vers { Some(v) => v, None => { let vers = ~"0.0"; warn_missing(sess, ~"vers", vers); vers } }; } let provided_metas = provided_link_metas(sess, c); let name = crate_meta_name(sess, c, output, provided_metas); let vers = crate_meta_vers(sess, c, provided_metas); let dep_hashes = cstore::get_dep_hashes(sess.cstore); let extras_hash = crate_meta_extras_hash(symbol_hasher, c, provided_metas, dep_hashes); return {name: name, vers: vers, extras_hash: extras_hash}; } fn truncated_hash_result(symbol_hasher: &hash::State) -> ~str unsafe { symbol_hasher.result_str() } // This calculates STH for a symbol, as defined above fn symbol_hash(tcx: ty::ctxt, symbol_hasher: &hash::State, t: ty::t, link_meta: link_meta) -> ~str { // NB: do *not* use abbrevs here as we want the symbol names // to be independent of one another in the crate. symbol_hasher.reset(); symbol_hasher.write_str(link_meta.name); symbol_hasher.write_str(~"-"); symbol_hasher.write_str(link_meta.extras_hash); symbol_hasher.write_str(~"-"); symbol_hasher.write_str(encoder::encoded_ty(tcx, t)); let hash = truncated_hash_result(symbol_hasher); // Prefix with _ so that it never blends into adjacent digits return ~"_" + hash; } fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> ~str { match ccx.type_hashcodes.find(t) { Some(h) => return h, None => { let hash = symbol_hash(ccx.tcx, ccx.symbol_hasher, t, ccx.link_meta); ccx.type_hashcodes.insert(t, hash); return hash; } } } // Name sanitation. LLVM will happily accept identifiers with weird names, but // gas doesn't! fn sanitize(s: ~str) -> ~str { let mut result = ~""; for str::chars_each(s) |c| { match c { '@' => result += ~"_sbox_", '~' => result += ~"_ubox_", '*' => result += ~"_ptr_", '&' => result += ~"_ref_", ',' => result += ~"_", '{' | '(' => result += ~"_of_", 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' => str::push_char(&mut result, c), _ => { if c > 'z' && char::is_XID_continue(c) { str::push_char(&mut result, c); } } } } // Underscore-qualify anything that didn't start as an ident. if result.len() > 0u && result[0] != '_' as u8 && ! char::is_XID_start(result[0] as char) { return ~"_" + result; } return result; } fn mangle(sess: session, ss: path) -> ~str { // Follow C++ namespace-mangling style let mut n = ~"_ZN"; // Begin name-sequence. for ss.each |s| { match *s { path_name(s) | path_mod(s) => { let sani = sanitize(sess.str_of(s)); n += fmt!("%u%s", str::len(sani), sani); } } } n += ~"E"; // End name-sequence. n } fn exported_name(sess: session, path: path, hash: ~str, vers: ~str) -> ~str { return mangle(sess, vec::append_one( vec::append_one(path, path_name(sess.ident_of(hash))), path_name(sess.ident_of(vers)))); } fn mangle_exported_name(ccx: @crate_ctxt, path: path, t: ty::t) -> ~str { let hash = get_symbol_hash(ccx, t); return exported_name(ccx.sess, path, hash, ccx.link_meta.vers); } fn mangle_internal_name_by_type_only(ccx: @crate_ctxt, t: ty::t, name: ~str) -> ~str { let s = util::ppaux::ty_to_short_str(ccx.tcx, t); let hash = get_symbol_hash(ccx, t); return mangle(ccx.sess, ~[path_name(ccx.sess.ident_of(name)), path_name(ccx.sess.ident_of(s)), path_name(ccx.sess.ident_of(hash))]); } fn mangle_internal_name_by_path_and_seq(ccx: @crate_ctxt, path: path, flav: ~str) -> ~str { return mangle(ccx.sess, vec::append_one(path, path_name(ccx.names(flav)))); } fn mangle_internal_name_by_path(ccx: @crate_ctxt, path: path) -> ~str { return mangle(ccx.sess, path); } fn mangle_internal_name_by_seq(ccx: @crate_ctxt, flav: ~str) -> ~str { return fmt!("%s_%u", flav, ccx.names(flav).repr); } // If the user wants an exe generated we need to invoke // cc to link the object file with some libs fn link_binary(sess: session, obj_filename: &Path, out_filename: &Path, lm: link_meta) { // Converts a library file-stem into a cc -l argument fn unlib(config: @session::config, stem: ~str) -> ~str { if stem.starts_with("lib") && config.os != session::os_win32 { stem.slice(3, stem.len()) } else { stem } } let output = if sess.building_library { let long_libname = os::dll_filename(fmt!("%s-%s-%s", lm.name, lm.extras_hash, lm.vers)); debug!("link_meta.name: %s", lm.name); debug!("long_libname: %s", long_libname); debug!("out_filename: %s", out_filename.to_str()); debug!("dirname(out_filename): %s", out_filename.dir_path().to_str()); out_filename.dir_path().push(long_libname) } else { *out_filename }; log(debug, ~"output: " + output.to_str()); // The default library location, we need this to find the runtime. // The location of crates will be determined as needed. let stage: ~str = ~"-L" + sess.filesearch.get_target_lib_path().to_str(); // In the future, FreeBSD will use clang as default compiler. // It would be flexible to use cc (system's default C compiler) // instead of hard-coded gcc. // 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" }; // The invocations of cc share some flags across platforms let mut cc_args = vec::append(~[stage], sess.targ_cfg.target_strs.cc_args); cc_args.push(~"-o"); cc_args.push(output.to_str()); cc_args.push(obj_filename.to_str()); let mut lib_cmd; let os = sess.targ_cfg.os; if os == session::os_macos { lib_cmd = ~"-dynamiclib"; } else { lib_cmd = ~"-shared"; } // # Crate linking let cstore = sess.cstore; for cstore::get_used_crate_files(cstore).each |cratepath| { if cratepath.filetype() == Some(~".rlib") { cc_args.push(cratepath.to_str()); loop; } let dir = cratepath.dirname(); if dir != ~"" { cc_args.push(~"-L" + dir); } let libarg = unlib(sess.targ_cfg, cratepath.filestem().get()); cc_args.push(~"-l" + libarg); } let ula = cstore::get_used_link_args(cstore); for ula.each |arg| { cc_args.push(*arg); } // # Extern library linking // User-supplied library search paths (-L on the cammand line) These are // the same paths used to find Rust crates, so some of them may have been // added already by the previous crate linking code. This only allows them // to be found at compile time so it is still entirely up to outside // forces to make sure that library can be found at runtime. let addl_paths = sess.opts.addl_lib_search_paths; for addl_paths.each |path| { cc_args.push(~"-L" + path.to_str()); } // The names of the extern libraries let used_libs = cstore::get_used_libraries(cstore); for used_libs.each |l| { cc_args.push(~"-l" + *l); } if sess.building_library { cc_args.push(lib_cmd); // On mac we need to tell the linker to let this library // be rpathed if sess.targ_cfg.os == session::os_macos { cc_args.push(~"-Wl,-install_name,@rpath/" + output.filename().get()); } } // Always want the runtime linked in cc_args.push(~"-lrustrt"); // On linux librt and libdl are an indirect dependencies via rustrt, // and binutils 2.22+ won't add them automatically if sess.targ_cfg.os == session::os_linux { cc_args.push_all(~[~"-lrt", ~"-ldl"]); // LLVM implements the `frem` instruction as a call to `fmod`, // which lives in libm. Similar to above, on some linuxes we // have to be explicit about linking to it. See #2510 cc_args.push(~"-lm"); } if sess.targ_cfg.os == session::os_freebsd { cc_args.push_all(~[~"-pthread", ~"-lrt", ~"-L/usr/local/lib", ~"-lexecinfo", ~"-L/usr/local/lib/gcc46", ~"-L/usr/local/lib/gcc44", ~"-lstdc++", ~"-Wl,-z,origin", ~"-Wl,-rpath,/usr/local/lib/gcc46", ~"-Wl,-rpath,/usr/local/lib/gcc44"]); } // OS X 10.6 introduced 'compact unwind info', which is produced by the // linker from the dwarf unwind info. Unfortunately, it does not seem to // understand how to unwind our __morestack frame, so we have to turn it // off. This has impacted some other projects like GHC. if sess.targ_cfg.os == session::os_macos { cc_args.push(~"-Wl,-no_compact_unwind"); } // Stack growth requires statically linking a __morestack function 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 cc_args.push_all(rpath::get_rpath_flags(sess, &output)); debug!("%s link args: %s", cc_prog, str::connect(cc_args, ~" ")); // We run 'cc' here let prog = run::program_output(cc_prog, cc_args); if 0 != prog.status { sess.err(fmt!("linking with `%s` failed with code %d", cc_prog, prog.status)); sess.note(fmt!("%s arguments: %s", cc_prog, str::connect(cc_args, ~" "))); sess.note(prog.err + prog.out); sess.abort_if_errors(); } // Clean up on Darwin if sess.targ_cfg.os == session::os_macos { run::run_program(~"dsymutil", ~[output.to_str()]); } // Remove the temporary object file if we aren't saving temps if !sess.opts.save_temps { if ! os::remove_file(obj_filename) { sess.warn(fmt!("failed to delete object file `%s`", obj_filename.to_str())); } } } // // Local Variables: // mode: rust // fill-column: 78; // indent-tabs-mode: nil // c-basic-offset: 4 // buffer-file-coding-system: utf-8-unix // End: //