bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

libcore: Remove vec::to_ptr in favor of vec::unsafe::to_ptr. Closes #1829.

Browse source
This commit is contained in:
Patrick Walton 2012-02-28 20:43:39 -08:00
parent d3331bce98
commit 362f23641a
7 changed files with 29 additions and 35 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/comp/lib/llvm.rs
View file

@ -988,7 +988,7 @@ fn type_to_str_inner(names: type_names, outer0: [TypeRef], ty: TypeRef) ->
let n_args = llvm::LLVMCountParamTypes(ty) as uint; let n_args = llvm::LLVMCountParamTypes(ty) as uint;
let args: [TypeRef] = vec::init_elt::<TypeRef>(n_args, 0 as TypeRef); let args: [TypeRef] = vec::init_elt::<TypeRef>(n_args, 0 as TypeRef);
unsafe { unsafe {
llvm::LLVMGetParamTypes(ty, vec::to_ptr(args)); llvm::LLVMGetParamTypes(ty, vec::unsafe::to_ptr(args));
} }
s += tys_str(names, outer, args); s += tys_str(names, outer, args);
s += ") -> "; s += ") -> ";
@ -1000,7 +1000,7 @@ fn type_to_str_inner(names: type_names, outer0: [TypeRef], ty: TypeRef) ->
let n_elts = llvm::LLVMCountStructElementTypes(ty) as uint; let n_elts = llvm::LLVMCountStructElementTypes(ty) as uint;
let elts: [TypeRef] = vec::init_elt::<TypeRef>(n_elts, 0 as TypeRef); let elts: [TypeRef] = vec::init_elt::<TypeRef>(n_elts, 0 as TypeRef);
unsafe { unsafe {
llvm::LLVMGetStructElementTypes(ty, vec::to_ptr(elts)); llvm::LLVMGetStructElementTypes(ty, vec::unsafe::to_ptr(elts));
} }
s += tys_str(names, outer, elts); s += tys_str(names, outer, elts);
s += "}"; s += "}";
@ -1043,7 +1043,7 @@ fn float_width(llt: TypeRef) -> uint {
fn fn_ty_param_tys(fn_ty: TypeRef) -> [TypeRef] unsafe { fn fn_ty_param_tys(fn_ty: TypeRef) -> [TypeRef] unsafe {
let args = vec::init_elt(llvm::LLVMCountParamTypes(fn_ty) as uint, let args = vec::init_elt(llvm::LLVMCountParamTypes(fn_ty) as uint,
0 as TypeRef); 0 as TypeRef);
llvm::LLVMGetParamTypes(fn_ty, vec::to_ptr(args)); llvm::LLVMGetParamTypes(fn_ty, vec::unsafe::to_ptr(args));
ret args; ret args;
} }

2
src/comp/middle/trans/base.rs
View file

@ -4428,7 +4428,7 @@ fn create_main_wrapper(ccx: crate_ctxt, sp: span, main_llfn: ValueRef,
let args = [rust_main, llvm::LLVMGetParam(llfn, 0 as c_uint), let args = [rust_main, llvm::LLVMGetParam(llfn, 0 as c_uint),
llvm::LLVMGetParam(llfn, 1 as c_uint), crate_map]; llvm::LLVMGetParam(llfn, 1 as c_uint), crate_map];
let result = unsafe { let result = unsafe {
llvm::LLVMBuildCall(bld, start, vec::to_ptr(args), llvm::LLVMBuildCall(bld, start, vec::unsafe::to_ptr(args),
args.len() as c_uint, noname()) args.len() as c_uint, noname())
}; };
llvm::LLVMBuildRet(bld, result); llvm::LLVMBuildRet(bld, result);

21
src/comp/middle/trans/build.rs
View file

@ -41,7 +41,7 @@ fn AggregateRet(cx: block, RetVals: [ValueRef]) {
assert (!cx.terminated); assert (!cx.terminated);
cx.terminated = true; cx.terminated = true;
unsafe { unsafe {
llvm::LLVMBuildAggregateRet(B(cx), vec::to_ptr(RetVals), llvm::LLVMBuildAggregateRet(B(cx), vec::unsafe::to_ptr(RetVals),
RetVals.len() as c_uint); RetVals.len() as c_uint);
} }
} }
@ -98,7 +98,7 @@ fn Invoke(cx: block, Fn: ValueRef, Args: [ValueRef],
str::connect(vec::map(Args, {|a|val_str(cx.ccx().tn, a)}), str::connect(vec::map(Args, {|a|val_str(cx.ccx().tn, a)}),
", ")]; ", ")];
unsafe { unsafe {
llvm::LLVMBuildInvoke(B(cx), Fn, vec::to_ptr(Args), llvm::LLVMBuildInvoke(B(cx), Fn, vec::unsafe::to_ptr(Args),
Args.len() as c_uint, Then, Catch, Args.len() as c_uint, Then, Catch,
noname()); noname());
} }
@ -110,7 +110,7 @@ fn FastInvoke(cx: block, Fn: ValueRef, Args: [ValueRef],
assert (!cx.terminated); assert (!cx.terminated);
cx.terminated = true; cx.terminated = true;
unsafe { unsafe {
let v = llvm::LLVMBuildInvoke(B(cx), Fn, vec::to_ptr(Args), let v = llvm::LLVMBuildInvoke(B(cx), Fn, vec::unsafe::to_ptr(Args),
Args.len() as c_uint, Args.len() as c_uint,
Then, Catch, noname()); Then, Catch, noname());
lib::llvm::SetInstructionCallConv(v, lib::llvm::FastCallConv); lib::llvm::SetInstructionCallConv(v, lib::llvm::FastCallConv);
@ -331,7 +331,7 @@ fn Store(cx: block, Val: ValueRef, Ptr: ValueRef) {
fn GEP(cx: block, Pointer: ValueRef, Indices: [ValueRef]) -> ValueRef { fn GEP(cx: block, Pointer: ValueRef, Indices: [ValueRef]) -> ValueRef {
if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); } if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); }
unsafe { unsafe {
ret llvm::LLVMBuildGEP(B(cx), Pointer, vec::to_ptr(Indices), ret llvm::LLVMBuildGEP(B(cx), Pointer, vec::unsafe::to_ptr(Indices),
Indices.len() as c_uint, noname()); Indices.len() as c_uint, noname());
} }
} }
@ -349,7 +349,7 @@ fn InBoundsGEP(cx: block, Pointer: ValueRef, Indices: [ValueRef]) ->
if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); } if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); }
unsafe { unsafe {
ret llvm::LLVMBuildInBoundsGEP(B(cx), Pointer, ret llvm::LLVMBuildInBoundsGEP(B(cx), Pointer,
vec::to_ptr(Indices), vec::unsafe::to_ptr(Indices),
Indices.len() as c_uint, Indices.len() as c_uint,
noname()); noname());
} }
@ -496,7 +496,8 @@ fn Phi(cx: block, Ty: TypeRef, vals: [ValueRef], bbs: [BasicBlockRef])
assert vals.len() == bbs.len(); assert vals.len() == bbs.len();
let phi = EmptyPhi(cx, Ty); let phi = EmptyPhi(cx, Ty);
unsafe { unsafe {
llvm::LLVMAddIncoming(phi, vec::to_ptr(vals), vec::to_ptr(bbs), llvm::LLVMAddIncoming(phi, vec::unsafe::to_ptr(vals),
vec::unsafe::to_ptr(bbs),
vals.len() as c_uint); vals.len() as c_uint);
ret phi; ret phi;
} }
@ -547,7 +548,7 @@ fn add_comment(bcx: block, text: str) {
fn Call(cx: block, Fn: ValueRef, Args: [ValueRef]) -> ValueRef { fn Call(cx: block, Fn: ValueRef, Args: [ValueRef]) -> ValueRef {
if cx.unreachable { ret _UndefReturn(cx, Fn); } if cx.unreachable { ret _UndefReturn(cx, Fn); }
unsafe { unsafe {
ret llvm::LLVMBuildCall(B(cx), Fn, vec::to_ptr(Args), ret llvm::LLVMBuildCall(B(cx), Fn, vec::unsafe::to_ptr(Args),
Args.len() as c_uint, noname()); Args.len() as c_uint, noname());
} }
} }
@ -555,7 +556,7 @@ fn Call(cx: block, Fn: ValueRef, Args: [ValueRef]) -> ValueRef {
fn FastCall(cx: block, Fn: ValueRef, Args: [ValueRef]) -> ValueRef { fn FastCall(cx: block, Fn: ValueRef, Args: [ValueRef]) -> ValueRef {
if cx.unreachable { ret _UndefReturn(cx, Fn); } if cx.unreachable { ret _UndefReturn(cx, Fn); }
unsafe { unsafe {
let v = llvm::LLVMBuildCall(B(cx), Fn, vec::to_ptr(Args), let v = llvm::LLVMBuildCall(B(cx), Fn, vec::unsafe::to_ptr(Args),
Args.len() as c_uint, noname()); Args.len() as c_uint, noname());
lib::llvm::SetInstructionCallConv(v, lib::llvm::FastCallConv); lib::llvm::SetInstructionCallConv(v, lib::llvm::FastCallConv);
ret v; ret v;
@ -566,7 +567,7 @@ fn CallWithConv(cx: block, Fn: ValueRef, Args: [ValueRef],
Conv: CallConv) -> ValueRef { Conv: CallConv) -> ValueRef {
if cx.unreachable { ret _UndefReturn(cx, Fn); } if cx.unreachable { ret _UndefReturn(cx, Fn); }
unsafe { unsafe {
let v = llvm::LLVMBuildCall(B(cx), Fn, vec::to_ptr(Args), let v = llvm::LLVMBuildCall(B(cx), Fn, vec::unsafe::to_ptr(Args),
Args.len() as c_uint, noname()); Args.len() as c_uint, noname());
lib::llvm::SetInstructionCallConv(v, Conv); lib::llvm::SetInstructionCallConv(v, Conv);
ret v; ret v;
@ -642,7 +643,7 @@ fn Trap(cx: block) {
assert (T as int != 0); assert (T as int != 0);
let Args: [ValueRef] = []; let Args: [ValueRef] = [];
unsafe { unsafe {
llvm::LLVMBuildCall(b, T, vec::to_ptr(Args), llvm::LLVMBuildCall(b, T, vec::unsafe::to_ptr(Args),
Args.len() as c_uint, noname()); Args.len() as c_uint, noname());
} }
} }

14
src/comp/middle/trans/common.rs
View file

@ -4,7 +4,7 @@
*/ */
import ctypes::unsigned; import ctypes::unsigned;
import vec::to_ptr; import vec::unsafe::to_ptr;
import std::map::hashmap; import std::map::hashmap;
import syntax::ast; import syntax::ast;
import driver::session; import driver::session;
@ -805,28 +805,28 @@ fn C_zero_byte_arr(size: uint) -> ValueRef unsafe {
let i = 0u; let i = 0u;
let elts: [ValueRef] = []; let elts: [ValueRef] = [];
while i < size { elts += [C_u8(0u)]; i += 1u; } while i < size { elts += [C_u8(0u)]; i += 1u; }
ret llvm::LLVMConstArray(T_i8(), vec::to_ptr(elts), ret llvm::LLVMConstArray(T_i8(), vec::unsafe::to_ptr(elts),
elts.len() as unsigned); elts.len() as unsigned);
} }
fn C_struct(elts: [ValueRef]) -> ValueRef unsafe { fn C_struct(elts: [ValueRef]) -> ValueRef unsafe {
ret llvm::LLVMConstStruct(vec::to_ptr(elts), elts.len() as unsigned, ret llvm::LLVMConstStruct(vec::unsafe::to_ptr(elts),
False); elts.len() as unsigned, False);
} }
fn C_named_struct(T: TypeRef, elts: [ValueRef]) -> ValueRef unsafe { fn C_named_struct(T: TypeRef, elts: [ValueRef]) -> ValueRef unsafe {
ret llvm::LLVMConstNamedStruct(T, vec::to_ptr(elts), ret llvm::LLVMConstNamedStruct(T, vec::unsafe::to_ptr(elts),
elts.len() as unsigned); elts.len() as unsigned);
} }
fn C_array(ty: TypeRef, elts: [ValueRef]) -> ValueRef unsafe { fn C_array(ty: TypeRef, elts: [ValueRef]) -> ValueRef unsafe {
ret llvm::LLVMConstArray(ty, vec::to_ptr(elts), ret llvm::LLVMConstArray(ty, vec::unsafe::to_ptr(elts),
elts.len() as unsigned); elts.len() as unsigned);
} }
fn C_bytes(bytes: [u8]) -> ValueRef unsafe { fn C_bytes(bytes: [u8]) -> ValueRef unsafe {
ret llvm::LLVMConstString( ret llvm::LLVMConstString(
unsafe::reinterpret_cast(vec::to_ptr(bytes)), unsafe::reinterpret_cast(vec::unsafe::to_ptr(bytes)),
bytes.len() as unsigned, False); bytes.len() as unsigned, False);
} }

2
src/comp/middle/trans/impl.rs
View file

@ -208,7 +208,7 @@ fn llfn_arg_tys(ft: TypeRef) -> {inputs: [TypeRef], output: TypeRef} {
let out_ty = llvm::LLVMGetReturnType(ft); let out_ty = llvm::LLVMGetReturnType(ft);
let n_args = llvm::LLVMCountParamTypes(ft); let n_args = llvm::LLVMCountParamTypes(ft);
let args = vec::init_elt(n_args as uint, 0 as TypeRef); let args = vec::init_elt(n_args as uint, 0 as TypeRef);
unsafe { llvm::LLVMGetParamTypes(ft, vec::to_ptr(args)); } unsafe { llvm::LLVMGetParamTypes(ft, vec::unsafe::to_ptr(args)); }
{inputs: args, output: out_ty} {inputs: args, output: out_ty}
} }

4
src/libcore/str.rs
View file

@ -2017,7 +2017,7 @@ mod tests {
#[test] #[test]
fn test_from_cstr() unsafe { fn test_from_cstr() unsafe {
let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8]; let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];
let b = vec::to_ptr(a); let b = vec::unsafe::to_ptr(a);
let c = from_cstr(b); let c = from_cstr(b);
assert (c == "AAAAAAA"); assert (c == "AAAAAAA");
} }
@ -2025,7 +2025,7 @@ mod tests {
#[test] #[test]
fn test_from_cstr_len() unsafe { fn test_from_cstr_len() unsafe {
let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8]; let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];
let b = vec::to_ptr(a); let b = vec::unsafe::to_ptr(a);
let c = from_cstr_len(b, 3u); let c = from_cstr_len(b, 3u);
assert (c == "AAA"); assert (c == "AAA");
} }

15
src/libcore/vec.rs
View file

@ -1068,13 +1068,6 @@ fn windowed <TT: copy> (nn: uint, xx: [TT]) -> [[TT]] {
ret ww; ret ww;
} }
/*
Function: to_ptr
FIXME: We don't need this wrapper
*/
unsafe fn to_ptr<T>(v: [T]) -> *T { ret unsafe::to_ptr(v); }
/* /*
Function: as_buf Function: as_buf
@ -1159,8 +1152,8 @@ mod u8 {
let a_len = len(a); let a_len = len(a);
let b_len = len(b); let b_len = len(b);
let n = math::min(a_len, b_len) as ctypes::size_t; let n = math::min(a_len, b_len) as ctypes::size_t;
let r = libc::memcmp(to_ptr(a) as *libc::c_void, let r = libc::memcmp(unsafe::to_ptr(a) as *libc::c_void,
to_ptr(b) as *libc::c_void, n) as int; unsafe::to_ptr(b) as *libc::c_void, n) as int;
if r != 0 { r } else { if r != 0 { r } else {
if a_len == b_len { if a_len == b_len {
@ -1253,7 +1246,7 @@ mod tests {
fn test_unsafe_ptrs() unsafe { fn test_unsafe_ptrs() unsafe {
// Test on-stack copy-from-buf. // Test on-stack copy-from-buf.
let a = [1, 2, 3]; let a = [1, 2, 3];
let ptr = to_ptr(a); let ptr = unsafe::to_ptr(a);
let b = unsafe::from_buf(ptr, 3u); let b = unsafe::from_buf(ptr, 3u);
assert (len(b) == 3u); assert (len(b) == 3u);
assert (b[0] == 1); assert (b[0] == 1);
@ -1262,7 +1255,7 @@ mod tests {
// Test on-heap copy-from-buf. // Test on-heap copy-from-buf.
let c = [1, 2, 3, 4, 5]; let c = [1, 2, 3, 4, 5];
ptr = to_ptr(c); ptr = unsafe::to_ptr(c);
let d = unsafe::from_buf(ptr, 5u); let d = unsafe::from_buf(ptr, 5u);
assert (len(d) == 5u); assert (len(d) == 5u);
assert (d[0] == 1); assert (d[0] == 1);