@@ -281,7 +281,11 @@ pub fn decl_rust_fn(ccx: &CrateContext, fn_ty: ty::t, name: &str) -> ValueRef {
281281
282282 let llfn = decl_fn ( ccx, name, llvm:: CCallConv , llfty, output) ;
283283 let attrs = get_fn_llvm_attributes ( ccx, fn_ty) ;
284- attrs. apply_llfn ( llfn) ;
284+ for & ( idx, attr) in attrs. iter ( ) {
285+ unsafe {
286+ llvm:: LLVMAddFunctionAttribute ( llfn, idx as c_uint , attr) ;
287+ }
288+ }
285289
286290 llfn
287291}
@@ -958,7 +962,7 @@ pub fn invoke<'a>(
958962 llargs. as_slice ( ) ,
959963 normal_bcx. llbb ,
960964 landing_pad,
961- Some ( attributes) ) ;
965+ attributes. as_slice ( ) ) ;
962966 return ( llresult, normal_bcx) ;
963967 } else {
964968 debug ! ( "calling {} at {}" , llfn, bcx. llbb) ;
@@ -971,7 +975,7 @@ pub fn invoke<'a>(
971975 None => debuginfo:: clear_source_location ( bcx. fcx )
972976 } ;
973977
974- let llresult = Call ( bcx, llfn, llargs. as_slice ( ) , Some ( attributes) ) ;
978+ let llresult = Call ( bcx, llfn, llargs. as_slice ( ) , attributes. as_slice ( ) ) ;
975979 return ( llresult, bcx) ;
976980 }
977981}
@@ -1077,7 +1081,7 @@ pub fn call_lifetime_start(cx: &Block, ptr: ValueRef) {
10771081 let llsize = C_u64 ( ccx, machine:: llsize_of_alloc ( ccx, val_ty ( ptr) . element_type ( ) ) ) ;
10781082 let ptr = PointerCast ( cx, ptr, Type :: i8p ( ccx) ) ;
10791083 let lifetime_start = ccx. get_intrinsic ( & "llvm.lifetime.start" ) ;
1080- Call ( cx, lifetime_start, [ llsize, ptr] , None ) ;
1084+ Call ( cx, lifetime_start, [ llsize, ptr] , [ ] ) ;
10811085}
10821086
10831087pub fn call_lifetime_end ( cx : & Block , ptr : ValueRef ) {
@@ -1091,7 +1095,7 @@ pub fn call_lifetime_end(cx: &Block, ptr: ValueRef) {
10911095 let llsize = C_u64 ( ccx, machine:: llsize_of_alloc ( ccx, val_ty ( ptr) . element_type ( ) ) ) ;
10921096 let ptr = PointerCast ( cx, ptr, Type :: i8p ( ccx) ) ;
10931097 let lifetime_end = ccx. get_intrinsic ( & "llvm.lifetime.end" ) ;
1094- Call ( cx, lifetime_end, [ llsize, ptr] , None ) ;
1098+ Call ( cx, lifetime_end, [ llsize, ptr] , [ ] ) ;
10951099}
10961100
10971101pub fn call_memcpy ( cx : & Block , dst : ValueRef , src : ValueRef , n_bytes : ValueRef , align : u32 ) {
@@ -1107,7 +1111,7 @@ pub fn call_memcpy(cx: &Block, dst: ValueRef, src: ValueRef, n_bytes: ValueRef,
11071111 let size = IntCast ( cx, n_bytes, ccx. int_type ) ;
11081112 let align = C_i32 ( ccx, align as i32 ) ;
11091113 let volatile = C_bool ( ccx, false ) ;
1110- Call ( cx, memcpy, [ dst_ptr, src_ptr, size, align, volatile] , None ) ;
1114+ Call ( cx, memcpy, [ dst_ptr, src_ptr, size, align, volatile] , [ ] ) ;
11111115}
11121116
11131117pub fn memcpy_ty ( bcx : & Block , dst : ValueRef , src : ValueRef , t : ty:: t ) {
@@ -1152,7 +1156,7 @@ fn memzero(b: &Builder, llptr: ValueRef, ty: Type) {
11521156 let size = machine:: llsize_of ( ccx, ty) ;
11531157 let align = C_i32 ( ccx, llalign_of_min ( ccx, ty) as i32 ) ;
11541158 let volatile = C_bool ( ccx, false ) ;
1155- b. call ( llintrinsicfn, [ llptr, llzeroval, size, align, volatile] , None ) ;
1159+ b. call ( llintrinsicfn, [ llptr, llzeroval, size, align, volatile] , [ ] ) ;
11561160}
11571161
11581162pub fn alloc_ty ( bcx : & Block , t : ty:: t , name : & str ) -> ValueRef {
@@ -2036,7 +2040,7 @@ fn register_fn(ccx: &CrateContext,
20362040}
20372041
20382042pub fn get_fn_llvm_attributes( ccx: & CrateContext , fn_ty: ty:: t)
2039- -> llvm :: AttrBuilder {
2043+ -> Vec < ( uint , u64 ) > {
20402044 use middle:: ty:: { BrAnon , ReLateBound } ;
20412045
20422046 let ( fn_sig, abi, has_env) = match ty:: get( fn_ty) . sty {
@@ -2052,33 +2056,31 @@ pub fn get_fn_llvm_attributes(ccx: &CrateContext, fn_ty: ty::t)
20522056 _ => fail!( "expected closure or function." )
20532057 } ;
20542058
2055- // Since index 0 is the return value of the llvm func, we start
2056- // at either 1 or 2 depending on whether there's an env slot or not
2057- let mut first_arg_offset = if has_env { 2 } else { 1 } ;
2058- let mut attrs = llvm:: AttrBuilder :: new( ) ;
2059- let ret_ty = fn_sig. output;
2060-
20612059 // These have an odd calling convention, so we skip them for now.
20622060 //
20632061 // FIXME(pcwalton): We don't have to skip them; just untuple the result.
20642062 if abi == RustCall {
2065- return attrs ;
2063+ return Vec :: new ( )
20662064 }
20672065
2066+ // Since index 0 is the return value of the llvm func, we start
2067+ // at either 1 or 2 depending on whether there's an env slot or not
2068+ let mut first_arg_offset = if has_env { 2 } else { 1 } ;
2069+ let mut attrs = Vec :: new( ) ;
2070+ let ret_ty = fn_sig. output;
2071+
20682072 // A function pointer is called without the declaration
20692073 // available, so we have to apply any attributes with ABI
20702074 // implications directly to the call instruction. Right now,
20712075 // the only attribute we need to worry about is `sret`.
20722076 if type_of:: return_uses_outptr( ccx, ret_ty) {
2073- let llret_sz = llsize_of_real ( ccx , type_of :: type_of ( ccx , ret_ty ) ) ;
2077+ attrs . push ( ( 1 , llvm :: StructRetAttribute as u64 ) ) ;
20742078
20752079 // The outptr can be noalias and nocapture because it's entirely
2076- // invisible to the program. We also know it's nonnull as well
2077- // as how many bytes we can dereference
2078- attrs. arg( 1 , llvm:: StructRetAttribute )
2079- . arg( 1 , llvm:: NoAliasAttribute )
2080- . arg( 1 , llvm:: NoCaptureAttribute )
2081- . arg( 1 , llvm:: DereferenceableAttribute ( llret_sz) ) ;
2080+ // invisible to the program. We can also mark it as nonnull
2081+ attrs. push( ( 1 , llvm:: NoAliasAttribute as u64 ) ) ;
2082+ attrs. push( ( 1 , llvm:: NoCaptureAttribute as u64 ) ) ;
2083+ attrs. push( ( 1 , llvm:: NonNullAttribute as u64 ) ) ;
20822084
20832085 // Add one more since there's an outptr
20842086 first_arg_offset += 1 ;
@@ -2092,28 +2094,27 @@ pub fn get_fn_llvm_attributes(ccx: &CrateContext, fn_ty: ty::t)
20922094 ty:: ty_str | ty:: ty_vec( ..) | ty:: ty_trait( ..) => true , _ => false
20932095 } => { }
20942096 ty:: ty_uniq( _) => {
2095- attrs. ret ( llvm:: NoAliasAttribute ) ;
2097+ attrs. push ( ( llvm:: ReturnIndex as uint , llvm :: NoAliasAttribute as u64 ) ) ;
20962098 }
20972099 _ => { }
20982100 }
20992101
2100- // We can also mark the return value as `dereferenceable ` in certain cases
2102+ // We can also mark the return value as `nonnull ` in certain cases
21012103 match ty:: get( ret_ty) . sty {
21022104 // These are not really pointers but pairs, (pointer, len)
21032105 ty:: ty_uniq( it) |
21042106 ty:: ty_rptr( _, ty:: mt { ty: it, .. } ) if match ty:: get( it) . sty {
21052107 ty:: ty_str | ty:: ty_vec( ..) | ty:: ty_trait( ..) => true , _ => false
21062108 } => { }
2107- ty:: ty_uniq( inner) | ty:: ty_rptr( _, ty:: mt { ty: inner, .. } ) => {
2108- let llret_sz = llsize_of_real( ccx, type_of:: type_of( ccx, inner) ) ;
2109- attrs. ret( llvm:: DereferenceableAttribute ( llret_sz) ) ;
2109+ ty:: ty_uniq( _) | ty:: ty_rptr( _, _) => {
2110+ attrs. push( ( llvm:: ReturnIndex as uint, llvm:: NonNullAttribute as u64 ) ) ;
21102111 }
21112112 _ => { }
21122113 }
21132114
21142115 match ty:: get( ret_ty) . sty {
21152116 ty:: ty_bool => {
2116- attrs. ret ( llvm:: ZExtAttribute ) ;
2117+ attrs. push ( ( llvm:: ReturnIndex as uint , llvm :: ZExtAttribute as u64 ) ) ;
21172118 }
21182119 _ => { }
21192120 }
@@ -2123,77 +2124,44 @@ pub fn get_fn_llvm_attributes(ccx: &CrateContext, fn_ty: ty::t)
21232124 match ty:: get( t) . sty {
21242125 // this needs to be first to prevent fat pointers from falling through
21252126 _ if !type_is_immediate( ccx, t) => {
2126- let llarg_sz = llsize_of_real( ccx, type_of:: type_of( ccx, t) ) ;
2127-
21282127 // For non-immediate arguments the callee gets its own copy of
21292128 // the value on the stack, so there are no aliases. It's also
21302129 // program-invisible so can't possibly capture
2131- attrs. arg ( idx, llvm:: NoAliasAttribute )
2132- . arg ( idx, llvm:: NoCaptureAttribute )
2133- . arg ( idx, llvm:: DereferenceableAttribute ( llarg_sz ) ) ;
2130+ attrs. push ( ( idx, llvm:: NoAliasAttribute as u64 ) ) ;
2131+ attrs . push ( ( idx, llvm:: NoCaptureAttribute as u64 ) ) ;
2132+ attrs . push ( ( idx, llvm:: NonNullAttribute as u64 ) ) ;
21342133 }
2135-
21362134 ty:: ty_bool => {
2137- attrs. arg ( idx, llvm:: ZExtAttribute ) ;
2135+ attrs. push ( ( idx, llvm:: ZExtAttribute as u64 ) ) ;
21382136 }
2139-
21402137 // `~` pointer parameters never alias because ownership is transferred
2141- ty:: ty_uniq( inner) => {
2142- let llsz = llsize_of_real( ccx, type_of:: type_of( ccx, inner) ) ;
2143-
2144- attrs. arg( idx, llvm:: NoAliasAttribute )
2145- . arg( idx, llvm:: DereferenceableAttribute ( llsz) ) ;
2146- }
2147-
2148- // The visit glue deals only with opaque pointers so we don't
2149- // actually know the concrete type of Self thus we don't know how
2150- // many bytes to mark as dereferenceable so instead we just mark
2151- // it as nonnull which still holds true
2152- ty:: ty_rptr( b, ty:: mt { ty: it, mutbl } ) if match ty:: get( it) . sty {
2153- ty:: ty_param( _) => true , _ => false
2154- } && mutbl == ast:: MutMutable => {
2155- attrs. arg( idx, llvm:: NoAliasAttribute )
2156- . arg( idx, llvm:: NonNullAttribute ) ;
2157-
2158- match b {
2159- ReLateBound ( _, BrAnon ( _) ) => {
2160- attrs. arg( idx, llvm:: NoCaptureAttribute ) ;
2161- }
2162- _ => { }
2163- }
2138+ ty:: ty_uniq( _) => {
2139+ attrs. push( ( idx, llvm:: NoAliasAttribute as u64 ) ) ;
2140+ attrs. push( ( idx, llvm:: NonNullAttribute as u64 ) ) ;
21642141 }
2165-
21662142 // `&mut` pointer parameters never alias other parameters, or mutable global data
21672143 // `&` pointer parameters never alias either (for LLVM's purposes) as long as the
21682144 // interior is safe
21692145 ty:: ty_rptr( b, mt) if mt. mutbl == ast:: MutMutable ||
21702146 !ty:: type_contents( ccx. tcx( ) , mt. ty) . interior_unsafe( ) => {
2171-
2172- let llsz = llsize_of_real( ccx, type_of:: type_of( ccx, mt. ty) ) ;
2173- attrs. arg( idx, llvm:: NoAliasAttribute )
2174- . arg( idx, llvm:: DereferenceableAttribute ( llsz) ) ;
2175-
2147+ attrs. push( ( idx, llvm:: NoAliasAttribute as u64 ) ) ;
2148+ attrs. push( ( idx, llvm:: NonNullAttribute as u64 ) ) ;
21762149 match b {
21772150 ReLateBound ( _, BrAnon ( _) ) => {
2178- attrs. arg ( idx, llvm:: NoCaptureAttribute ) ;
2151+ attrs. push ( ( idx, llvm:: NoCaptureAttribute as u64 ) ) ;
21792152 }
21802153 _ => { }
21812154 }
21822155 }
2183-
21842156 // When a reference in an argument has no named lifetime, it's impossible for that
21852157 // reference to escape this function (returned or stored beyond the call by a closure).
2186- ty:: ty_rptr( ReLateBound ( _, BrAnon ( _) ) , mt) => {
2187- let llsz = llsize_of_real( ccx, type_of:: type_of( ccx, mt. ty) ) ;
2188- attrs. arg( idx, llvm:: NoCaptureAttribute )
2189- . arg( idx, llvm:: DereferenceableAttribute ( llsz) ) ;
2158+ ty:: ty_rptr( ReLateBound ( _, BrAnon ( _) ) , _) => {
2159+ attrs. push( ( idx, llvm:: NoCaptureAttribute as u64 ) ) ;
2160+ attrs. push( ( idx, llvm:: NonNullAttribute as u64 ) ) ;
21902161 }
2191-
2192- // & pointer parameters are also never null and we know exactly how
2193- // many bytes we can dereference
2194- ty:: ty_rptr( _, mt) => {
2195- let llsz = llsize_of_real( ccx, type_of:: type_of( ccx, mt. ty) ) ;
2196- attrs. arg( idx, llvm:: DereferenceableAttribute ( llsz) ) ;
2162+ // & pointer parameters are never null
2163+ ty:: ty_rptr( _, _) => {
2164+ attrs. push( ( idx, llvm:: NonNullAttribute as u64 ) ) ;
21972165 }
21982166 _ => ( )
21992167 }
0 commit comments