use ModuleLlvm;
use rustc_codegen_ssa::{ModuleCodegen, CompiledModule};
use rustc::util::common::time_ext;
-use rustc_fs_util::{path2cstr, link_or_copy};
+use rustc_fs_util::{path_to_c_string, link_or_copy};
use rustc_data_structures::small_c_str::SmallCStr;
use errors::{self, Handler, FatalError};
use type_::Type;
output: &Path,
file_type: llvm::FileType) -> Result<(), FatalError> {
unsafe {
- let output_c = path2cstr(output);
+ let output_c = path_to_c_string(output);
let result = llvm::LLVMRustWriteOutputFile(target, pm, m, output_c.as_ptr(), file_type);
if result.into_result().is_err() {
let msg = format!("could not write output to {}", output.display());
let ext = format!("{}.bc", name);
let cgu = Some(&module.name[..]);
let path = cgcx.output_filenames.temp_path_ext(&ext, cgu);
- let cstr = path2cstr(&path);
+ let cstr = path_to_c_string(&path);
let llmod = module.module_llvm.llmod();
llvm::LLVMWriteBitcodeToFile(llmod, cstr.as_ptr());
}
if config.emit_no_opt_bc {
let out = cgcx.output_filenames.temp_path_ext("no-opt.bc", module_name);
- let out = path2cstr(&out);
+ let out = path_to_c_string(&out);
llvm::LLVMWriteBitcodeToFile(llmod, out.as_ptr());
}
|| -> Result<(), FatalError> {
if config.emit_ir {
let out = cgcx.output_filenames.temp_path(OutputType::LlvmAssembly, module_name);
- let out = path2cstr(&out);
+ let out = path_to_c_string(&out);
extern "C" fn demangle_callback(input_ptr: *const c_char,
input_len: size_t,
PrimitiveExt, Size, TyLayout};
use rustc::session::config;
use rustc::util::nodemap::FxHashMap;
-use rustc_fs_util::path2cstr;
+use rustc_fs_util::path_to_c_string;
use rustc_data_structures::small_c_str::SmallCStr;
use libc::{c_uint, c_longlong};
};
fn path_to_mdstring(llcx: &'ll llvm::Context, path: &Path) -> &'ll Value {
- let path_str = path2cstr(path);
+ let path_str = path_to_c_string(path);
unsafe {
llvm::LLVMMDStringInContext(llcx,
path_str.as_ptr(),
//! A wrapper around LLVM's archive (.a) code
-use std::ffi::CString;
use std::path::Path;
use std::slice;
use std::str;
+use rustc_fs_util::path_to_c_string;
pub struct ArchiveRO {
pub raw: &'static mut super::Archive,
/// raised.
pub fn open(dst: &Path) -> Result<ArchiveRO, String> {
return unsafe {
- let s = path2cstr(dst);
+ let s = path_to_c_string(dst);
let ar = super::LLVMRustOpenArchive(s.as_ptr()).ok_or_else(|| {
super::last_error().unwrap_or_else(|| "failed to open archive".to_owned())
})?;
Ok(ArchiveRO { raw: ar })
};
-
- #[cfg(unix)]
- fn path2cstr(p: &Path) -> CString {
- use std::os::unix::prelude::*;
- use std::ffi::OsStr;
- let p: &OsStr = p.as_ref();
- CString::new(p.as_bytes()).unwrap()
- }
- #[cfg(windows)]
- fn path2cstr(p: &Path) -> CString {
- CString::new(p.to_str().unwrap()).unwrap()
- }
}
pub fn iter(&self) -> Iter {
use std::path::Path;
use std::ptr;
use std::slice;
-use rustc_fs_util::path2cstr;
+use rustc_fs_util::path_to_c_string;
pub use rustc_data_structures::sync::MetadataRef;
filename: &Path)
-> Result<MetadataRef, String> {
unsafe {
- let buf = path2cstr(filename);
+ let buf = path_to_c_string(filename);
let mb = llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(buf.as_ptr())
.ok_or_else(|| format!("error reading library: '{}'", filename.display()))?;
let of = ObjectFile::new(mb)
}
#[cfg(unix)]
-pub fn path2cstr(p: &Path) -> CString {
- use std::os::unix::prelude::*;
+pub fn path_to_c_string(p: &Path) -> CString {
+ use std::os::unix::ffi::OsStrExt;
use std::ffi::OsStr;
let p: &OsStr = p.as_ref();
CString::new(p.as_bytes()).unwrap()
}
#[cfg(windows)]
-pub fn path2cstr(p: &Path) -> CString {
+pub fn path_to_c_string(p: &Path) -> CString {
CString::new(p.to_str().unwrap()).unwrap()
}