Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
int
Rust
提交
f7a997be
R
Rust
项目概览
int
/
Rust
大约 1 年 前同步成功
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
R
Rust
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
f7a997be
编写于
9月 06, 2014
作者:
E
Eduard Burtescu
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
rustc: fix fallout from the addition of a 'tcx lifetime on trans::Block.
上级
28be695b
变更
20
展开全部
隐藏空白更改
内联
并排
Showing
20 changed file
with
1095 addition
and
1135 deletion
+1095
-1135
src/librustc/middle/trans/_match.rs
src/librustc/middle/trans/_match.rs
+144
-153
src/librustc/middle/trans/adt.rs
src/librustc/middle/trans/adt.rs
+16
-16
src/librustc/middle/trans/asm.rs
src/librustc/middle/trans/asm.rs
+2
-2
src/librustc/middle/trans/base.rs
src/librustc/middle/trans/base.rs
+122
-134
src/librustc/middle/trans/build.rs
src/librustc/middle/trans/build.rs
+108
-108
src/librustc/middle/trans/callee.rs
src/librustc/middle/trans/callee.rs
+66
-69
src/librustc/middle/trans/cleanup.rs
src/librustc/middle/trans/cleanup.rs
+46
-46
src/librustc/middle/trans/closure.rs
src/librustc/middle/trans/closure.rs
+39
-42
src/librustc/middle/trans/common.rs
src/librustc/middle/trans/common.rs
+33
-30
src/librustc/middle/trans/controlflow.rs
src/librustc/middle/trans/controlflow.rs
+56
-58
src/librustc/middle/trans/datum.rs
src/librustc/middle/trans/datum.rs
+95
-96
src/librustc/middle/trans/debuginfo.rs
src/librustc/middle/trans/debuginfo.rs
+5
-5
src/librustc/middle/trans/expr.rs
src/librustc/middle/trans/expr.rs
+208
-213
src/librustc/middle/trans/foreign.rs
src/librustc/middle/trans/foreign.rs
+7
-8
src/librustc/middle/trans/glue.rs
src/librustc/middle/trans/glue.rs
+42
-39
src/librustc/middle/trans/intrinsic.rs
src/librustc/middle/trans/intrinsic.rs
+9
-8
src/librustc/middle/trans/meth.rs
src/librustc/middle/trans/meth.rs
+35
-37
src/librustc/middle/trans/reflect.rs
src/librustc/middle/trans/reflect.rs
+9
-10
src/librustc/middle/trans/tvec.rs
src/librustc/middle/trans/tvec.rs
+52
-60
src/librustc/middle/trans/value.rs
src/librustc/middle/trans/value.rs
+1
-1
未找到文件。
src/librustc/middle/trans/_match.rs
浏览文件 @
f7a997be
此差异已折叠。
点击以展开。
src/librustc/middle/trans/adt.rs
浏览文件 @
f7a997be
...
...
@@ -143,7 +143,7 @@ pub struct Struct {
* these, for places in trans where the `ty::t` isn't directly
* available.
*/
pub
fn
represent_node
(
bcx
:
&
Block
,
node
:
ast
::
NodeId
)
->
Rc
<
Repr
>
{
pub
fn
represent_node
(
bcx
:
Block
,
node
:
ast
::
NodeId
)
->
Rc
<
Repr
>
{
represent_type
(
bcx
.ccx
(),
node_id_type
(
bcx
,
node
))
}
...
...
@@ -574,7 +574,7 @@ fn struct_llfields(cx: &CrateContext, st: &Struct, sizing: bool, dst: bool) -> V
*
* This should ideally be less tightly tied to `_match`.
*/
pub
fn
trans_switch
(
bcx
:
&
Block
,
r
:
&
Repr
,
scrutinee
:
ValueRef
)
pub
fn
trans_switch
(
bcx
:
Block
,
r
:
&
Repr
,
scrutinee
:
ValueRef
)
->
(
_
match
::
BranchKind
,
Option
<
ValueRef
>
)
{
match
*
r
{
CEnum
(
..
)
|
General
(
..
)
|
...
...
@@ -590,7 +590,7 @@ pub fn trans_switch(bcx: &Block, r: &Repr, scrutinee: ValueRef)
/// Obtain the actual discriminant of a value.
pub
fn
trans_get_discr
(
bcx
:
&
Block
,
r
:
&
Repr
,
scrutinee
:
ValueRef
,
cast_to
:
Option
<
Type
>
)
pub
fn
trans_get_discr
(
bcx
:
Block
,
r
:
&
Repr
,
scrutinee
:
ValueRef
,
cast_to
:
Option
<
Type
>
)
->
ValueRef
{
let
signed
;
let
val
;
...
...
@@ -625,7 +625,7 @@ pub fn trans_get_discr(bcx: &Block, r: &Repr, scrutinee: ValueRef, cast_to: Opti
}
}
fn
struct_wrapped_nullable_bitdiscr
(
bcx
:
&
Block
,
nndiscr
:
Disr
,
ptrfield
:
PointerField
,
fn
struct_wrapped_nullable_bitdiscr
(
bcx
:
Block
,
nndiscr
:
Disr
,
ptrfield
:
PointerField
,
scrutinee
:
ValueRef
)
->
ValueRef
{
let
llptrptr
=
match
ptrfield
{
ThinPointer
(
field
)
=>
GEPi
(
bcx
,
scrutinee
,
[
0
,
field
]),
...
...
@@ -637,7 +637,7 @@ fn struct_wrapped_nullable_bitdiscr(bcx: &Block, nndiscr: Disr, ptrfield: Pointe
}
/// Helper for cases where the discriminant is simply loaded.
fn
load_discr
(
bcx
:
&
Block
,
ity
:
IntType
,
ptr
:
ValueRef
,
min
:
Disr
,
max
:
Disr
)
fn
load_discr
(
bcx
:
Block
,
ity
:
IntType
,
ptr
:
ValueRef
,
min
:
Disr
,
max
:
Disr
)
->
ValueRef
{
let
llty
=
ll_inttype
(
bcx
.ccx
(),
ity
);
assert_eq!
(
val_ty
(
ptr
),
llty
.ptr_to
());
...
...
@@ -666,8 +666,8 @@ fn load_discr(bcx: &Block, ity: IntType, ptr: ValueRef, min: Disr, max: Disr)
*
* This should ideally be less tightly tied to `_match`.
*/
pub
fn
trans_case
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
r
:
&
Repr
,
discr
:
Disr
)
->
_
match
::
OptResult
<
'a
>
{
pub
fn
trans_case
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
r
:
&
Repr
,
discr
:
Disr
)
->
_
match
::
OptResult
<
'blk
,
'tcx
>
{
match
*
r
{
CEnum
(
ity
,
_
,
_
)
=>
{
_
match
::
SingleResult
(
Result
::
new
(
bcx
,
C_integral
(
ll_inttype
(
bcx
.ccx
(),
ity
),
...
...
@@ -692,7 +692,7 @@ pub fn trans_case<'a>(bcx: &'a Block<'a>, r: &Repr, discr: Disr)
* Set the discriminant for a new value of the given case of the given
* representation.
*/
pub
fn
trans_set_discr
(
bcx
:
&
Block
,
r
:
&
Repr
,
val
:
ValueRef
,
discr
:
Disr
)
{
pub
fn
trans_set_discr
(
bcx
:
Block
,
r
:
&
Repr
,
val
:
ValueRef
,
discr
:
Disr
)
{
match
*
r
{
CEnum
(
ity
,
min
,
max
)
=>
{
assert_discr_in_range
(
ity
,
min
,
max
,
discr
);
...
...
@@ -770,7 +770,7 @@ pub fn num_args(r: &Repr, discr: Disr) -> uint {
}
/// Access a field, at a point when the value's case is known.
pub
fn
trans_field_ptr
(
bcx
:
&
Block
,
r
:
&
Repr
,
val
:
ValueRef
,
discr
:
Disr
,
pub
fn
trans_field_ptr
(
bcx
:
Block
,
r
:
&
Repr
,
val
:
ValueRef
,
discr
:
Disr
,
ix
:
uint
)
->
ValueRef
{
// Note: if this ever needs to generate conditionals (e.g., if we
// decide to do some kind of cdr-coding-like non-unique repr
...
...
@@ -809,7 +809,7 @@ pub fn trans_field_ptr(bcx: &Block, r: &Repr, val: ValueRef, discr: Disr,
}
}
pub
fn
struct_field_ptr
(
bcx
:
&
Block
,
st
:
&
Struct
,
val
:
ValueRef
,
pub
fn
struct_field_ptr
(
bcx
:
Block
,
st
:
&
Struct
,
val
:
ValueRef
,
ix
:
uint
,
needs_cast
:
bool
)
->
ValueRef
{
let
val
=
if
needs_cast
{
let
ccx
=
bcx
.ccx
();
...
...
@@ -823,10 +823,10 @@ pub fn struct_field_ptr(bcx: &Block, st: &Struct, val: ValueRef,
GEPi
(
bcx
,
val
,
[
0
,
ix
])
}
pub
fn
fold_variants
<
'
r
,
'b
>
(
bcx
:
&
'b
Block
<
'b
>
,
r
:
&
Repr
,
value
:
ValueRef
,
f
:
|
&
'b
Block
<
'b
>
,
&
Struct
,
ValueRef
|:
'r
->
&
'b
Block
<
'b
>
)
->
&
'b
Block
<
'b
>
{
pub
fn
fold_variants
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
r
:
&
Repr
,
value
:
ValueRef
,
f
:
|
Block
<
'blk
,
'tcx
>
,
&
Struct
,
ValueRef
|
->
Block
<
'blk
,
'tcx
>
)
->
Block
<
'blk
,
'tcx
>
{
let
fcx
=
bcx
.fcx
;
match
*
r
{
Univariant
(
ref
st
,
_
)
=>
{
...
...
@@ -864,8 +864,8 @@ pub fn fold_variants<'r, 'b>(
}
/// Access the struct drop flag, if present.
pub
fn
trans_drop_flag_ptr
<
'b
>
(
mut
bcx
:
&
'b
Block
<
'b
>
,
r
:
&
Repr
,
val
:
ValueRef
)
->
datum
::
DatumBlock
<
'b
,
datum
::
Expr
>
{
pub
fn
trans_drop_flag_ptr
<
'b
lk
,
'tcx
>
(
mut
bcx
:
Block
<
'blk
,
'tcx
>
,
r
:
&
Repr
,
val
:
ValueRef
)
->
datum
::
DatumBlock
<
'blk
,
'tcx
,
datum
::
Expr
>
{
let
ptr_ty
=
ty
::
mk_imm_ptr
(
bcx
.tcx
(),
ty
::
mk_bool
());
match
*
r
{
Univariant
(
ref
st
,
true
)
=>
{
...
...
src/librustc/middle/trans/asm.rs
浏览文件 @
f7a997be
...
...
@@ -27,8 +27,8 @@
use
syntax
::
ast
;
// Take an inline assembly expression and splat it out via LLVM
pub
fn
trans_inline_asm
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
ia
:
&
ast
::
InlineAsm
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_inline_asm
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
ia
:
&
ast
::
InlineAsm
)
->
Block
<
'blk
,
'tcx
>
{
let
fcx
=
bcx
.fcx
;
let
mut
bcx
=
bcx
;
let
mut
constraints
=
Vec
::
new
();
...
...
src/librustc/middle/trans/base.rs
浏览文件 @
f7a997be
此差异已折叠。
点击以展开。
src/librustc/middle/trans/build.rs
浏览文件 @
f7a997be
此差异已折叠。
点击以展开。
src/librustc/middle/trans/callee.rs
浏览文件 @
f7a997be
...
...
@@ -80,12 +80,13 @@ pub enum CalleeData {
TraitItem
(
MethodData
)
}
pub
struct
Callee
<
'
a
>
{
pub
bcx
:
&
'a
Block
<
'a
>
,
pub
struct
Callee
<
'
blk
,
'tcx
:
'blk
>
{
pub
bcx
:
Block
<
'blk
,
'tcx
>
,
pub
data
:
CalleeData
,
}
fn
trans
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
expr
:
&
ast
::
Expr
)
->
Callee
<
'a
>
{
fn
trans
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
expr
:
&
ast
::
Expr
)
->
Callee
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"trans_callee"
);
debug!
(
"callee::trans(expr={})"
,
expr
.repr
(
bcx
.tcx
()));
...
...
@@ -100,7 +101,8 @@ fn trans<'a>(bcx: &'a Block<'a>, expr: &ast::Expr) -> Callee<'a> {
// any other expressions are closures:
return
datum_callee
(
bcx
,
expr
);
fn
datum_callee
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
expr
:
&
ast
::
Expr
)
->
Callee
<
'a
>
{
fn
datum_callee
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
expr
:
&
ast
::
Expr
)
->
Callee
<
'blk
,
'tcx
>
{
let
DatumBlock
{
bcx
:
mut
bcx
,
datum
}
=
expr
::
trans
(
bcx
,
expr
);
match
ty
::
get
(
datum
.ty
)
.sty
{
ty
::
ty_bare_fn
(
..
)
=>
{
...
...
@@ -128,15 +130,16 @@ fn datum_callee<'a>(bcx: &'a Block<'a>, expr: &ast::Expr) -> Callee<'a> {
}
}
fn
fn_callee
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
llfn
:
ValueRef
)
->
Callee
<
'a
>
{
fn
fn_callee
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
llfn
:
ValueRef
)
->
Callee
<
'blk
,
'tcx
>
{
return
Callee
{
bcx
:
bcx
,
data
:
Fn
(
llfn
),
};
}
fn
trans_def
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
def
:
def
::
Def
,
ref_expr
:
&
ast
::
Expr
)
->
Callee
<
'a
>
{
fn
trans_def
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
def
:
def
::
Def
,
ref_expr
:
&
ast
::
Expr
)
->
Callee
<
'blk
,
'tcx
>
{
debug!
(
"trans_def(def={}, ref_expr={})"
,
def
.repr
(
bcx
.tcx
()),
ref_expr
.repr
(
bcx
.tcx
()));
let
expr_ty
=
node_id_type
(
bcx
,
ref_expr
.id
);
match
def
{
...
...
@@ -214,7 +217,7 @@ fn trans_def<'a>(bcx: &'a Block<'a>, def: def::Def, ref_expr: &ast::Expr)
}
}
pub
fn
trans_fn_ref
(
bcx
:
&
Block
,
def_id
:
ast
::
DefId
,
node
:
ExprOrMethodCall
)
->
ValueRef
{
pub
fn
trans_fn_ref
(
bcx
:
Block
,
def_id
:
ast
::
DefId
,
node
:
ExprOrMethodCall
)
->
ValueRef
{
/*!
* Translates a reference (with id `ref_id`) to the fn/method
* with id `def_id` into a function pointer. This may require
...
...
@@ -237,12 +240,12 @@ pub fn trans_fn_ref(bcx: &Block, def_id: ast::DefId, node: ExprOrMethodCall) ->
trans_fn_ref_with_vtables
(
bcx
,
def_id
,
node
,
substs
,
vtables
)
}
fn
trans_fn_ref_with_vtables_to_callee
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
def_id
:
ast
::
DefId
,
ref_id
:
ast
::
NodeId
,
substs
:
subst
::
Substs
,
vtables
:
typeck
::
vtable_res
)
->
Callee
<
'a
>
{
fn
trans_fn_ref_with_vtables_to_callee
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
def_id
:
ast
::
DefId
,
ref_id
:
ast
::
NodeId
,
substs
:
subst
::
Substs
,
vtables
:
typeck
::
vtable_res
)
->
Callee
<
'blk
,
'tcx
>
{
Callee
{
bcx
:
bcx
,
data
:
Fn
(
trans_fn_ref_with_vtables
(
bcx
,
...
...
@@ -253,7 +256,7 @@ fn trans_fn_ref_with_vtables_to_callee<'a>(bcx: &'a Block<'a>,
}
}
fn
resolve_default_method_vtables
(
bcx
:
&
Block
,
fn
resolve_default_method_vtables
(
bcx
:
Block
,
impl_id
:
ast
::
DefId
,
substs
:
&
subst
::
Substs
,
impl_vtables
:
typeck
::
vtable_res
)
...
...
@@ -281,7 +284,7 @@ fn resolve_default_method_vtables(bcx: &Block,
/// Translates the adapter that deconstructs a `Box<Trait>` object into
/// `Trait` so that a by-value self method can be called.
pub
fn
trans_unboxing_shim
(
bcx
:
&
Block
,
pub
fn
trans_unboxing_shim
(
bcx
:
Block
,
llshimmedfn
:
ValueRef
,
fty
:
&
ty
::
BareFnTy
,
method_id
:
ast
::
DefId
,
...
...
@@ -406,7 +409,7 @@ pub fn trans_unboxing_shim(bcx: &Block,
}
pub
fn
trans_fn_ref_with_vtables
(
bcx
:
&
Block
,
//
bcx
:
Block
,
//
def_id
:
ast
::
DefId
,
// def id of fn
node
:
ExprOrMethodCall
,
// node id of use of fn; may be zero if N/A
substs
:
subst
::
Substs
,
// values for fn's ty params
...
...
@@ -625,13 +628,12 @@ pub fn trans_fn_ref_with_vtables(
// ______________________________________________________________________
// Translating calls
pub
fn
trans_call
<
'a
>
(
in_cx
:
&
'a
Block
<
'a
>
,
call_ex
:
&
ast
::
Expr
,
f
:
&
ast
::
Expr
,
args
:
CallArgs
,
dest
:
expr
::
Dest
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_call
<
'blk
,
'tcx
>
(
in_cx
:
Block
<
'blk
,
'tcx
>
,
call_ex
:
&
ast
::
Expr
,
f
:
&
ast
::
Expr
,
args
:
CallArgs
,
dest
:
expr
::
Dest
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"trans_call"
);
trans_call_inner
(
in_cx
,
Some
(
common
::
expr_info
(
call_ex
)),
...
...
@@ -641,13 +643,12 @@ pub fn trans_call<'a>(
Some
(
dest
))
.bcx
}
pub
fn
trans_method_call
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
call_ex
:
&
ast
::
Expr
,
rcvr
:
&
ast
::
Expr
,
args
:
CallArgs
,
dest
:
expr
::
Dest
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_method_call
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
call_ex
:
&
ast
::
Expr
,
rcvr
:
&
ast
::
Expr
,
args
:
CallArgs
,
dest
:
expr
::
Dest
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"trans_method_call"
);
debug!
(
"trans_method_call(call_ex={})"
,
call_ex
.repr
(
bcx
.tcx
()));
let
method_call
=
MethodCall
::
expr
(
call_ex
.id
);
...
...
@@ -663,12 +664,11 @@ pub fn trans_method_call<'a>(
Some
(
dest
))
.bcx
}
pub
fn
trans_lang_call
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
did
:
ast
::
DefId
,
args
:
&
[
ValueRef
],
dest
:
Option
<
expr
::
Dest
>
)
->
Result
<
'a
>
{
pub
fn
trans_lang_call
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
did
:
ast
::
DefId
,
args
:
&
[
ValueRef
],
dest
:
Option
<
expr
::
Dest
>
)
->
Result
<
'blk
,
'tcx
>
{
let
fty
=
if
did
.krate
==
ast
::
LOCAL_CRATE
{
ty
::
node_id_to_type
(
bcx
.tcx
(),
did
.node
)
}
else
{
...
...
@@ -688,16 +688,15 @@ pub fn trans_lang_call<'a>(
dest
)
}
pub
fn
trans_call_inner
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
call_info
:
Option
<
NodeInfo
>
,
callee_ty
:
ty
::
t
,
get_callee
:
|
bcx
:
&
'a
Block
<
'a
>
,
arg_cleanup_scope
:
cleanup
::
ScopeId
|
->
Callee
<
'a
>
,
args
:
CallArgs
,
dest
:
Option
<
expr
::
Dest
>
)
->
Result
<
'a
>
{
pub
fn
trans_call_inner
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
call_info
:
Option
<
NodeInfo
>
,
callee_ty
:
ty
::
t
,
get_callee
:
|
bcx
:
Block
<
'blk
,
'tcx
>
,
arg_cleanup_scope
:
cleanup
::
ScopeId
|
->
Callee
<
'blk
,
'tcx
>
,
args
:
CallArgs
,
dest
:
Option
<
expr
::
Dest
>
)
->
Result
<
'blk
,
'tcx
>
{
/*!
* This behemoth of a function translates function calls.
* Unfortunately, in order to generate more efficient LLVM
...
...
@@ -920,14 +919,14 @@ pub enum CallArgs<'a> {
ArgOverloadedCall
(
&
'a
[
Gc
<
ast
::
Expr
>
]),
}
fn
trans_args_under_call_abi
<
'
a
>
(
mut
bcx
:
&
'a
Block
<
'a
>
,
fn
trans_args_under_call_abi
<
'
blk
,
'tcx
>
(
mut
bcx
:
Block
<
'blk
,
'tcx
>
,
arg_exprs
:
&
[
Gc
<
ast
::
Expr
>
],
fn_ty
:
ty
::
t
,
llargs
:
&
mut
Vec
<
ValueRef
>
,
arg_cleanup_scope
:
cleanup
::
ScopeId
,
ignore_self
:
bool
)
->
&
'a
Block
<
'a
>
{
->
Block
<
'blk
,
'tcx
>
{
// Translate the `self` argument first.
let
arg_tys
=
ty
::
ty_fn_args
(
fn_ty
);
if
!
ignore_self
{
...
...
@@ -981,14 +980,14 @@ fn trans_args_under_call_abi<'a>(
bcx
}
fn
trans_overloaded_call_args
<
'
a
>
(
mut
bcx
:
&
'a
Block
<
'a
>
,
fn
trans_overloaded_call_args
<
'
blk
,
'tcx
>
(
mut
bcx
:
Block
<
'blk
,
'tcx
>
,
arg_exprs
:
&
[
Gc
<
ast
::
Expr
>
],
fn_ty
:
ty
::
t
,
llargs
:
&
mut
Vec
<
ValueRef
>
,
arg_cleanup_scope
:
cleanup
::
ScopeId
,
ignore_self
:
bool
)
->
&
'a
Block
<
'a
>
{
->
Block
<
'blk
,
'tcx
>
{
// Translate the `self` argument first.
let
arg_tys
=
ty
::
ty_fn_args
(
fn_ty
);
if
!
ignore_self
{
...
...
@@ -1028,15 +1027,14 @@ fn trans_overloaded_call_args<'a>(
bcx
}
pub
fn
trans_args
<
'a
>
(
cx
:
&
'a
Block
<
'a
>
,
args
:
CallArgs
,
fn_ty
:
ty
::
t
,
llargs
:
&
mut
Vec
<
ValueRef
>
,
arg_cleanup_scope
:
cleanup
::
ScopeId
,
ignore_self
:
bool
,
abi
:
synabi
::
Abi
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_args
<
'blk
,
'tcx
>
(
cx
:
Block
<
'blk
,
'tcx
>
,
args
:
CallArgs
,
fn_ty
:
ty
::
t
,
llargs
:
&
mut
Vec
<
ValueRef
>
,
arg_cleanup_scope
:
cleanup
::
ScopeId
,
ignore_self
:
bool
,
abi
:
synabi
::
Abi
)
->
Block
<
'blk
,
'tcx
>
{
debug!
(
"trans_args(abi={})"
,
abi
);
let
_
icx
=
push_ctxt
(
"trans_args"
);
...
...
@@ -1124,13 +1122,12 @@ pub enum AutorefArg {
DoAutorefArg
(
ast
::
NodeId
)
}
pub
fn
trans_arg_datum
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
formal_arg_ty
:
ty
::
t
,
arg_datum
:
Datum
<
Expr
>
,
arg_cleanup_scope
:
cleanup
::
ScopeId
,
autoref_arg
:
AutorefArg
)
->
Result
<
'a
>
{
pub
fn
trans_arg_datum
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
formal_arg_ty
:
ty
::
t
,
arg_datum
:
Datum
<
Expr
>
,
arg_cleanup_scope
:
cleanup
::
ScopeId
,
autoref_arg
:
AutorefArg
)
->
Result
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"trans_arg_datum"
);
let
mut
bcx
=
bcx
;
let
ccx
=
bcx
.ccx
();
...
...
src/librustc/middle/trans/cleanup.rs
浏览文件 @
f7a997be
...
...
@@ -25,13 +25,13 @@
use
syntax
::
ast
;
use
util
::
ppaux
::
Repr
;
pub
struct
CleanupScope
<
'
a
>
{
pub
struct
CleanupScope
<
'
blk
,
'tcx
:
'blk
>
{
// The id of this cleanup scope. If the id is None,
// this is a *temporary scope* that is pushed during trans to
// cleanup miscellaneous garbage that trans may generate whose
// lifetime is a subset of some expression. See module doc for
// more details.
kind
:
CleanupScopeKind
<
'
a
>
,
kind
:
CleanupScopeKind
<
'
blk
,
'tcx
>
,
// Cleanups to run upon scope exit.
cleanups
:
Vec
<
CleanupObj
>
,
...
...
@@ -48,10 +48,10 @@ pub struct CustomScopeIndex {
pub
static
EXIT_LOOP
:
uint
=
1
;
pub
static
EXIT_MAX
:
uint
=
2
;
pub
enum
CleanupScopeKind
<
'
a
>
{
pub
enum
CleanupScopeKind
<
'
blk
,
'tcx
:
'blk
>
{
CustomScopeKind
,
AstScopeKind
(
ast
::
NodeId
),
LoopScopeKind
(
ast
::
NodeId
,
[
&
'a
Block
<
'a
>
,
..
EXIT_MAX
])
LoopScopeKind
(
ast
::
NodeId
,
[
Block
<
'blk
,
'tcx
>
,
..
EXIT_MAX
])
}
#[deriving(PartialEq)]
...
...
@@ -69,7 +69,7 @@ pub struct CachedEarlyExit {
pub
trait
Cleanup
{
fn
must_unwind
(
&
self
)
->
bool
;
fn
clean_on_unwind
(
&
self
)
->
bool
;
fn
trans
<
'
a
>
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
)
->
&
'a
Block
<
'a
>
;
fn
trans
<
'
blk
,
'tcx
>
(
&
self
,
bcx
:
Block
<
'blk
,
'tcx
>
)
->
Block
<
'blk
,
'tcx
>
;
}
pub
type
CleanupObj
=
Box
<
Cleanup
+
'static
>
;
...
...
@@ -79,7 +79,7 @@ pub enum ScopeId {
CustomScope
(
CustomScopeIndex
)
}
impl
<
'
a
>
CleanupMethods
<
'a
>
for
FunctionContext
<
'a
>
{
impl
<
'
blk
,
'tcx
>
CleanupMethods
<
'blk
,
'tcx
>
for
FunctionContext
<
'blk
,
'tcx
>
{
fn
push_ast_cleanup_scope
(
&
self
,
id
:
ast
::
NodeId
)
{
/*!
* Invoked when we start to trans the code contained
...
...
@@ -109,7 +109,7 @@ fn push_ast_cleanup_scope(&self, id: ast::NodeId) {
fn
push_loop_cleanup_scope
(
&
self
,
id
:
ast
::
NodeId
,
exits
:
[
&
'a
Block
<
'a
>
,
..
EXIT_MAX
])
{
exits
:
[
Block
<
'blk
,
'tcx
>
,
..
EXIT_MAX
])
{
debug!
(
"push_loop_cleanup_scope({})"
,
self
.ccx
.tcx
()
.map
.node_to_string
(
id
));
assert_eq!
(
Some
(
id
),
self
.top_ast_scope
());
...
...
@@ -125,9 +125,9 @@ fn push_custom_cleanup_scope(&self) -> CustomScopeIndex {
}
fn
pop_and_trans_ast_cleanup_scope
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
,
bcx
:
Block
<
'blk
,
'tcx
>
,
cleanup_scope
:
ast
::
NodeId
)
->
&
'a
Block
<
'a
>
{
->
Block
<
'blk
,
'tcx
>
{
/*!
* Removes the cleanup scope for id `cleanup_scope`, which
* must be at the top of the cleanup stack, and generates the
...
...
@@ -175,9 +175,9 @@ fn pop_custom_cleanup_scope(&self,
}
fn
pop_and_trans_custom_cleanup_scope
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
,
bcx
:
Block
<
'blk
,
'tcx
>
,
custom_scope
:
CustomScopeIndex
)
->
&
'a
Block
<
'a
>
{
->
Block
<
'blk
,
'tcx
>
{
/*!
* Removes the top cleanup scope from the stack, which must be
* a temporary scope, and generates the code to do its
...
...
@@ -207,7 +207,7 @@ fn top_loop_scope(&self) -> ast::NodeId {
self
.ccx
.sess
()
.bug
(
"no loop scope found"
);
}
fn
normal_exit_block
(
&
'
a
self
,
fn
normal_exit_block
(
&
'
blk
self
,
cleanup_scope
:
ast
::
NodeId
,
exit
:
uint
)
->
BasicBlockRef
{
/*!
...
...
@@ -219,7 +219,7 @@ fn normal_exit_block(&'a self,
self
.trans_cleanups_to_exit_scope
(
LoopExit
(
cleanup_scope
,
exit
))
}
fn
return_exit_block
(
&
'
a
self
)
->
BasicBlockRef
{
fn
return_exit_block
(
&
'
blk
self
)
->
BasicBlockRef
{
/*!
* Returns a block to branch to which will perform all pending
* cleanups and then return from this function
...
...
@@ -426,7 +426,7 @@ fn needs_invoke(&self) -> bool {
self
.scopes
.borrow
()
.iter
()
.rev
()
.any
(|
s
|
s
.needs_invoke
())
}
fn
get_landing_pad
(
&
'
a
self
)
->
BasicBlockRef
{
fn
get_landing_pad
(
&
'
blk
self
)
->
BasicBlockRef
{
/*!
* Returns a basic block to branch to in the event of a failure.
* This block will run the failure cleanups and eventually
...
...
@@ -464,7 +464,7 @@ fn get_landing_pad(&'a self) -> BasicBlockRef {
}
}
impl
<
'
a
>
CleanupHelperMethods
<
'a
>
for
FunctionContext
<
'a
>
{
impl
<
'
blk
,
'tcx
>
CleanupHelperMethods
<
'blk
,
'tcx
>
for
FunctionContext
<
'blk
,
'tcx
>
{
fn
top_ast_scope
(
&
self
)
->
Option
<
ast
::
NodeId
>
{
/*!
* Returns the id of the current top-most AST scope, if any.
...
...
@@ -496,8 +496,8 @@ fn is_valid_custom_scope(&self, custom_scope: CustomScopeIndex) -> bool {
}
fn
trans_scope_cleanups
(
&
self
,
// cannot borrow self, will recurse
bcx
:
&
'a
Block
<
'a
>
,
scope
:
&
CleanupScope
)
->
&
'a
Block
<
'a
>
{
bcx
:
Block
<
'blk
,
'tcx
>
,
scope
:
&
CleanupScope
)
->
Block
<
'blk
,
'tcx
>
{
/*! Generates the cleanups for `scope` into `bcx` */
let
mut
bcx
=
bcx
;
...
...
@@ -513,11 +513,11 @@ fn scopes_len(&self) -> uint {
self
.scopes
.borrow
()
.len
()
}
fn
push_scope
(
&
self
,
scope
:
CleanupScope
<
'
a
>
)
{
fn
push_scope
(
&
self
,
scope
:
CleanupScope
<
'
blk
,
'tcx
>
)
{
self
.scopes
.borrow_mut
()
.push
(
scope
)
}
fn
pop_scope
(
&
self
)
->
CleanupScope
<
'
a
>
{
fn
pop_scope
(
&
self
)
->
CleanupScope
<
'
blk
,
'tcx
>
{
debug!
(
"popping cleanup scope {}, {} scopes remaining"
,
self
.top_scope
(|
s
|
s
.block_name
(
""
)),
self
.scopes_len
()
-
1
);
...
...
@@ -525,11 +525,11 @@ fn pop_scope(&self) -> CleanupScope<'a> {
self
.scopes
.borrow_mut
()
.pop
()
.unwrap
()
}
fn
top_scope
<
R
>
(
&
self
,
f
:
|
&
CleanupScope
<
'
a
>
|
->
R
)
->
R
{
fn
top_scope
<
R
>
(
&
self
,
f
:
|
&
CleanupScope
<
'
blk
,
'tcx
>
|
->
R
)
->
R
{
f
(
self
.scopes
.borrow
()
.last
()
.unwrap
())
}
fn
trans_cleanups_to_exit_scope
(
&
'
a
self
,
fn
trans_cleanups_to_exit_scope
(
&
'
blk
self
,
label
:
EarlyExitLabel
)
->
BasicBlockRef
{
/*!
...
...
@@ -691,7 +691,7 @@ fn trans_cleanups_to_exit_scope(&'a self,
prev_llbb
}
fn
get_or_create_landing_pad
(
&
'
a
self
)
->
BasicBlockRef
{
fn
get_or_create_landing_pad
(
&
'
blk
self
)
->
BasicBlockRef
{
/*!
* Creates a landing pad for the top scope, if one does not
* exist. The landing pad will perform all cleanups necessary
...
...
@@ -784,8 +784,8 @@ fn get_or_create_landing_pad(&'a self) -> BasicBlockRef {
}
}
impl
<
'
a
>
CleanupScope
<
'a
>
{
fn
new
(
kind
:
CleanupScopeKind
<
'
a
>
)
->
CleanupScope
<
'a
>
{
impl
<
'
blk
,
'tcx
>
CleanupScope
<
'blk
,
'tcx
>
{
fn
new
(
kind
:
CleanupScopeKind
<
'
blk
,
'tcx
>
)
->
CleanupScope
<
'blk
,
'tcx
>
{
CleanupScope
{
kind
:
kind
,
cleanups
:
vec!
(),
...
...
@@ -836,7 +836,7 @@ fn block_name(&self, prefix: &str) -> String {
}
}
impl
<
'
a
>
CleanupScopeKind
<
'a
>
{
impl
<
'
blk
,
'tcx
>
CleanupScopeKind
<
'blk
,
'tcx
>
{
fn
is_temp
(
&
self
)
->
bool
{
match
*
self
{
CustomScopeKind
=>
true
,
...
...
@@ -902,7 +902,7 @@ fn clean_on_unwind(&self) -> bool {
self
.must_unwind
}
fn
trans
<
'
a
>
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
)
->
&
'a
Block
<
'a
>
{
fn
trans
<
'
blk
,
'tcx
>
(
&
self
,
bcx
:
Block
<
'blk
,
'tcx
>
)
->
Block
<
'blk
,
'tcx
>
{
let
bcx
=
if
self
.is_immediate
{
glue
::
drop_ty_immediate
(
bcx
,
self
.val
,
self
.ty
)
}
else
{
...
...
@@ -935,7 +935,7 @@ fn clean_on_unwind(&self) -> bool {
true
}
fn
trans
<
'
a
>
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
)
->
&
'a
Block
<
'a
>
{
fn
trans
<
'
blk
,
'tcx
>
(
&
self
,
bcx
:
Block
<
'blk
,
'tcx
>
)
->
Block
<
'blk
,
'tcx
>
{
match
self
.heap
{
HeapManaged
=>
{
glue
::
trans_free
(
bcx
,
self
.ptr
)
...
...
@@ -963,7 +963,7 @@ fn clean_on_unwind(&self) -> bool {
true
}
fn
trans
<
'
a
>
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
)
->
&
'a
Block
<
'a
>
{
fn
trans
<
'
blk
,
'tcx
>
(
&
self
,
bcx
:
Block
<
'blk
,
'tcx
>
)
->
Block
<
'blk
,
'tcx
>
{
match
self
.heap
{
HeapManaged
=>
{
glue
::
trans_free
(
bcx
,
self
.ptr
)
...
...
@@ -988,7 +988,7 @@ fn clean_on_unwind(&self) -> bool {
true
}
fn
trans
<
'
a
>
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
)
->
&
'a
Block
<
'a
>
{
fn
trans
<
'
blk
,
'tcx
>
(
&
self
,
bcx
:
Block
<
'blk
,
'tcx
>
)
->
Block
<
'blk
,
'tcx
>
{
base
::
call_lifetime_end
(
bcx
,
self
.ptr
);
bcx
}
...
...
@@ -1026,29 +1026,29 @@ fn cleanup_is_suitable_for(c: &Cleanup,
///////////////////////////////////////////////////////////////////////////
// These traits just exist to put the methods into this file.
pub
trait
CleanupMethods
<
'
a
>
{
pub
trait
CleanupMethods
<
'
blk
,
'tcx
>
{
fn
push_ast_cleanup_scope
(
&
self
,
id
:
ast
::
NodeId
);
fn
push_loop_cleanup_scope
(
&
self
,
id
:
ast
::
NodeId
,
exits
:
[
&
'a
Block
<
'a
>
,
..
EXIT_MAX
]);
exits
:
[
Block
<
'blk
,
'tcx
>
,
..
EXIT_MAX
]);
fn
push_custom_cleanup_scope
(
&
self
)
->
CustomScopeIndex
;
fn
pop_and_trans_ast_cleanup_scope
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
,
bcx
:
Block
<
'blk
,
'tcx
>
,
cleanup_scope
:
ast
::
NodeId
)
->
&
'a
Block
<
'a
>
;
->
Block
<
'blk
,
'tcx
>
;
fn
pop_loop_cleanup_scope
(
&
self
,
cleanup_scope
:
ast
::
NodeId
);
fn
pop_custom_cleanup_scope
(
&
self
,
custom_scope
:
CustomScopeIndex
);
fn
pop_and_trans_custom_cleanup_scope
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
,
bcx
:
Block
<
'blk
,
'tcx
>
,
custom_scope
:
CustomScopeIndex
)
->
&
'a
Block
<
'a
>
;
->
Block
<
'blk
,
'tcx
>
;
fn
top_loop_scope
(
&
self
)
->
ast
::
NodeId
;
fn
normal_exit_block
(
&
'
a
self
,
fn
normal_exit_block
(
&
'
blk
self
,
cleanup_scope
:
ast
::
NodeId
,
exit
:
uint
)
->
BasicBlockRef
;
fn
return_exit_block
(
&
'
a
self
)
->
BasicBlockRef
;
fn
return_exit_block
(
&
'
blk
self
)
->
BasicBlockRef
;
fn
schedule_lifetime_end
(
&
self
,
cleanup_scope
:
ScopeId
,
val
:
ValueRef
);
...
...
@@ -1085,23 +1085,23 @@ fn schedule_clean_in_custom_scope(&self,
custom_scope
:
CustomScopeIndex
,
cleanup
:
CleanupObj
);
fn
needs_invoke
(
&
self
)
->
bool
;
fn
get_landing_pad
(
&
'
a
self
)
->
BasicBlockRef
;
fn
get_landing_pad
(
&
'
blk
self
)
->
BasicBlockRef
;
}
trait
CleanupHelperMethods
<
'
a
>
{
trait
CleanupHelperMethods
<
'
blk
,
'tcx
>
{
fn
top_ast_scope
(
&
self
)
->
Option
<
ast
::
NodeId
>
;
fn
top_nonempty_cleanup_scope
(
&
self
)
->
Option
<
uint
>
;
fn
is_valid_to_pop_custom_scope
(
&
self
,
custom_scope
:
CustomScopeIndex
)
->
bool
;
fn
is_valid_custom_scope
(
&
self
,
custom_scope
:
CustomScopeIndex
)
->
bool
;
fn
trans_scope_cleanups
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
,
scope
:
&
CleanupScope
<
'
a
>
)
->
&
'a
Block
<
'a
>
;
fn
trans_cleanups_to_exit_scope
(
&
'
a
self
,
bcx
:
Block
<
'blk
,
'tcx
>
,
scope
:
&
CleanupScope
<
'
blk
,
'tcx
>
)
->
Block
<
'blk
,
'tcx
>
;
fn
trans_cleanups_to_exit_scope
(
&
'
blk
self
,
label
:
EarlyExitLabel
)
->
BasicBlockRef
;
fn
get_or_create_landing_pad
(
&
'
a
self
)
->
BasicBlockRef
;
fn
get_or_create_landing_pad
(
&
'
blk
self
)
->
BasicBlockRef
;
fn
scopes_len
(
&
self
)
->
uint
;
fn
push_scope
(
&
self
,
scope
:
CleanupScope
<
'
a
>
);
fn
pop_scope
(
&
self
)
->
CleanupScope
<
'
a
>
;
fn
top_scope
<
R
>
(
&
self
,
f
:
|
&
CleanupScope
<
'
a
>
|
->
R
)
->
R
;
fn
push_scope
(
&
self
,
scope
:
CleanupScope
<
'
blk
,
'tcx
>
);
fn
pop_scope
(
&
self
)
->
CleanupScope
<
'
blk
,
'tcx
>
;
fn
top_scope
<
R
>
(
&
self
,
f
:
|
&
CleanupScope
<
'
blk
,
'tcx
>
|
->
R
)
->
R
;
}
src/librustc/middle/trans/closure.rs
浏览文件 @
f7a997be
...
...
@@ -135,10 +135,10 @@ fn tuplify_box_ty(tcx: &ty::ctxt, t: ty::t) -> ty::t {
ty
::
mk_tup
(
tcx
,
vec!
(
ty
::
mk_uint
(),
ty
::
mk_nil_ptr
(
tcx
),
ptr
,
ptr
,
t
))
}
fn
allocate_cbox
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
store
:
ty
::
TraitStore
,
cdata_ty
:
ty
::
t
)
->
Result
<
'a
>
{
fn
allocate_cbox
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
store
:
ty
::
TraitStore
,
cdata_ty
:
ty
::
t
)
->
Result
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"closure::allocate_cbox"
);
let
tcx
=
bcx
.tcx
();
...
...
@@ -155,21 +155,20 @@ fn allocate_cbox<'a>(bcx: &'a Block<'a>,
}
}
pub
struct
ClosureResult
<
'
a
>
{
pub
struct
ClosureResult
<
'
blk
,
'tcx
:
'blk
>
{
llbox
:
ValueRef
,
// llvalue of ptr to closure
cdata_ty
:
ty
::
t
,
// type of the closure data
bcx
:
&
'a
Block
<
'a
>
// final bcx
bcx
:
Block
<
'blk
,
'tcx
>
// final bcx
}
// Given a block context and a list of tydescs and values to bind
// construct a closure out of them. If copying is true, it is a
// heap allocated closure that copies the upvars into environment.
// Otherwise, it is stack allocated and copies pointers to the upvars.
pub
fn
store_environment
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
bound_values
:
Vec
<
EnvValue
>
,
store
:
ty
::
TraitStore
)
->
ClosureResult
<
'a
>
{
pub
fn
store_environment
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
bound_values
:
Vec
<
EnvValue
>
,
store
:
ty
::
TraitStore
)
->
ClosureResult
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"closure::store_environment"
);
let
ccx
=
bcx
.ccx
();
let
tcx
=
ccx
.tcx
();
...
...
@@ -224,12 +223,11 @@ pub fn store_environment<'a>(
// Given a context and a list of upvars, build a closure. This just
// collects the upvars and packages them up for store_environment.
fn
build_closure
<
'a
>
(
bcx0
:
&
'a
Block
<
'a
>
,
freevar_mode
:
freevars
::
CaptureMode
,
freevars
:
&
Vec
<
freevars
::
freevar_entry
>
,
store
:
ty
::
TraitStore
)
->
ClosureResult
<
'a
>
{
fn
build_closure
<
'blk
,
'tcx
>
(
bcx0
:
Block
<
'blk
,
'tcx
>
,
freevar_mode
:
freevars
::
CaptureMode
,
freevars
:
&
Vec
<
freevars
::
freevar_entry
>
,
store
:
ty
::
TraitStore
)
->
ClosureResult
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"closure::build_closure"
);
// If we need to, package up the iterator body to call
...
...
@@ -248,11 +246,11 @@ fn build_closure<'a>(bcx0: &'a Block<'a>,
// Given an enclosing block context, a new function context, a closure type,
// and a list of upvars, generate code to load and populate the environment
// with the upvars and type descriptors.
fn
load_environment
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
cdata_ty
:
ty
::
t
,
freevars
:
&
Vec
<
freevars
::
freevar_entry
>
,
store
:
ty
::
TraitStore
)
->
&
'a
Block
<
'a
>
{
fn
load_environment
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
cdata_ty
:
ty
::
t
,
freevars
:
&
Vec
<
freevars
::
freevar_entry
>
,
store
:
ty
::
TraitStore
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"closure::load_environment"
);
// Don't bother to create the block if there's nothing to load
...
...
@@ -301,12 +299,12 @@ fn load_environment<'a>(bcx: &'a Block<'a>,
bcx
}
fn
load_unboxed_closure_environment
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
fn
load_unboxed_closure_environment
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
arg_scope_id
:
ScopeId
,
freevars
:
&
Vec
<
freevars
::
freevar_entry
>
,
closure_id
:
ast
::
DefId
)
->
&
'a
Block
<
'a
>
{
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"closure::load_environment"
);
if
freevars
.len
()
==
0
{
...
...
@@ -343,20 +341,19 @@ fn load_unboxed_closure_environment<'a>(
bcx
}
fn
fill_fn_pair
(
bcx
:
&
Block
,
pair
:
ValueRef
,
llfn
:
ValueRef
,
llenvptr
:
ValueRef
)
{
fn
fill_fn_pair
(
bcx
:
Block
,
pair
:
ValueRef
,
llfn
:
ValueRef
,
llenvptr
:
ValueRef
)
{
Store
(
bcx
,
llfn
,
GEPi
(
bcx
,
pair
,
[
0u
,
abi
::
fn_field_code
]));
let
llenvptr
=
PointerCast
(
bcx
,
llenvptr
,
Type
::
i8p
(
bcx
.ccx
()));
Store
(
bcx
,
llenvptr
,
GEPi
(
bcx
,
pair
,
[
0u
,
abi
::
fn_field_box
]));
}
pub
fn
trans_expr_fn
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
store
:
ty
::
TraitStore
,
decl
:
&
ast
::
FnDecl
,
body
:
&
ast
::
Block
,
id
:
ast
::
NodeId
,
dest
:
expr
::
Dest
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_expr_fn
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
store
:
ty
::
TraitStore
,
decl
:
&
ast
::
FnDecl
,
body
:
&
ast
::
Block
,
id
:
ast
::
NodeId
,
dest
:
expr
::
Dest
)
->
Block
<
'blk
,
'tcx
>
{
/*!
*
* Translates the body of a closure expression.
...
...
@@ -458,13 +455,13 @@ pub fn get_or_create_declaration_if_unboxed_closure(ccx: &CrateContext,
Some
(
llfn
)
}
pub
fn
trans_unboxed_closure
<
'
a
>
(
mut
bcx
:
&
'a
Block
<
'a
>
,
pub
fn
trans_unboxed_closure
<
'
blk
,
'tcx
>
(
mut
bcx
:
Block
<
'blk
,
'tcx
>
,
decl
:
&
ast
::
FnDecl
,
body
:
&
ast
::
Block
,
id
:
ast
::
NodeId
,
dest
:
expr
::
Dest
)
->
&
'a
Block
<
'a
>
{
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"closure::trans_unboxed_closure"
);
debug!
(
"trans_unboxed_closure()"
);
...
...
@@ -620,11 +617,11 @@ pub fn get_wrapper_for_bare_fn(ccx: &CrateContext,
llfn
}
pub
fn
make_closure_from_bare_fn
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
closure_ty
:
ty
::
t
,
def
:
def
::
Def
,
fn_ptr
:
ValueRef
)
->
DatumBlock
<
'a
,
Expr
>
{
pub
fn
make_closure_from_bare_fn
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
closure_ty
:
ty
::
t
,
def
:
def
::
Def
,
fn_ptr
:
ValueRef
)
->
DatumBlock
<
'blk
,
'tcx
,
Expr
>
{
let
scratch
=
rvalue_scratch_datum
(
bcx
,
closure_ty
,
"__adjust"
);
let
wrapper
=
get_wrapper_for_bare_fn
(
bcx
.ccx
(),
closure_ty
,
def
,
fn_ptr
,
true
);
fill_fn_pair
(
bcx
,
scratch
.val
,
wrapper
,
C_null
(
Type
::
i8p
(
bcx
.ccx
())));
...
...
src/librustc/middle/trans/common.rs
浏览文件 @
f7a997be
...
...
@@ -294,7 +294,7 @@ pub struct FunctionContext<'a, 'tcx: 'a> {
pub
span
:
Option
<
Span
>
,
// The arena that blocks are allocated from.
pub
block_arena
:
&
'a
TypedArena
<
Block
<
'a
>>
,
pub
block_arena
:
&
'a
TypedArena
<
Block
S
<
'a
,
'tcx
>>
,
// This function's enclosing crate context.
pub
ccx
:
&
'a
CrateContext
<
'a
,
'tcx
>
,
...
...
@@ -303,7 +303,7 @@ pub struct FunctionContext<'a, 'tcx: 'a> {
pub
debug_context
:
debuginfo
::
FunctionDebugContext
,
// Cleanup scopes.
pub
scopes
:
RefCell
<
Vec
<
cleanup
::
CleanupScope
<
'a
>>
>
,
pub
scopes
:
RefCell
<
Vec
<
cleanup
::
CleanupScope
<
'a
,
'tcx
>>
>
,
}
impl
<
'a
,
'tcx
>
FunctionContext
<
'a
,
'tcx
>
{
...
...
@@ -350,7 +350,7 @@ pub fn get_llreturn(&self) -> BasicBlockRef {
self
.llreturn
.get
()
.unwrap
()
}
pub
fn
get_ret_slot
(
&
self
,
bcx
:
&
Block
,
ty
:
ty
::
t
,
name
:
&
str
)
->
ValueRef
{
pub
fn
get_ret_slot
(
&
self
,
bcx
:
Block
,
ty
:
ty
::
t
,
name
:
&
str
)
->
ValueRef
{
if
self
.needs_ret_allocas
{
base
::
alloca_no_lifetime
(
bcx
,
type_of
::
type_of
(
bcx
.ccx
(),
ty
),
name
)
}
else
{
...
...
@@ -362,34 +362,34 @@ pub fn new_block(&'a self,
is_lpad
:
bool
,
name
:
&
str
,
opt_node_id
:
Option
<
ast
::
NodeId
>
)
->
&
'a
Block
<
'a
>
{
->
Block
<
'a
,
'tcx
>
{
unsafe
{
let
llbb
=
name
.with_c_str
(|
buf
|
{
llvm
::
LLVMAppendBasicBlockInContext
(
self
.ccx
.llcx
(),
self
.llfn
,
buf
)
});
Block
::
new
(
llbb
,
is_lpad
,
opt_node_id
,
self
)
Block
S
::
new
(
llbb
,
is_lpad
,
opt_node_id
,
self
)
}
}
pub
fn
new_id_block
(
&
'a
self
,
name
:
&
str
,
node_id
:
ast
::
NodeId
)
->
&
'a
Block
<
'a
>
{
->
Block
<
'a
,
'tcx
>
{
self
.new_block
(
false
,
name
,
Some
(
node_id
))
}
pub
fn
new_temp_block
(
&
'a
self
,
name
:
&
str
)
->
&
'a
Block
<
'a
>
{
->
Block
<
'a
,
'tcx
>
{
self
.new_block
(
false
,
name
,
None
)
}
pub
fn
join_blocks
(
&
'a
self
,
id
:
ast
::
NodeId
,
in_cxs
:
&
[
&
'a
Block
<
'a
>
])
->
&
'a
Block
<
'a
>
{
in_cxs
:
&
[
Block
<
'a
,
'tcx
>
])
->
Block
<
'a
,
'tcx
>
{
let
out
=
self
.new_id_block
(
"join"
,
id
);
let
mut
reachable
=
false
;
for
bcx
in
in_cxs
.iter
()
{
...
...
@@ -410,7 +410,7 @@ pub fn join_blocks(&'a self,
// code. Each basic block we generate is attached to a function, typically
// with many basic blocks per function. All the basic blocks attached to a
// function are organized as a directed graph.
pub
struct
Block
<
'a
,
'tcx
>
{
pub
struct
Block
S
<
'blk
,
'tcx
:
'blk
>
{
// The BasicBlockRef returned from a call to
// llvm::LLVMAppendBasicBlock(llfn, name), which adds a basic
// block to the function pointed to by llfn. We insert
...
...
@@ -429,16 +429,18 @@ pub struct Block<'a, 'tcx> {
// The function context for the function to which this block is
// attached.
pub
fcx
:
&
'
a
FunctionContext
<
'a
,
'tcx
>
,
pub
fcx
:
&
'
blk
FunctionContext
<
'blk
,
'tcx
>
,
}
impl
<
'a
,
'tcx
>
Block
<
'a
,
'tcx
>
{
pub
type
Block
<
'blk
,
'tcx
>
=
&
'blk
BlockS
<
'blk
,
'tcx
>
;
impl
<
'blk
,
'tcx
>
BlockS
<
'blk
,
'tcx
>
{
pub
fn
new
(
llbb
:
BasicBlockRef
,
is_lpad
:
bool
,
opt_node_id
:
Option
<
ast
::
NodeId
>
,
fcx
:
&
'
a
FunctionContext
<
'a
,
'tcx
>
)
->
&
'a
Block
<
'a
,
'tcx
>
{
fcx
.block_arena
.alloc
(
Block
{
fcx
:
&
'
blk
FunctionContext
<
'blk
,
'tcx
>
)
->
Block
<
'blk
,
'tcx
>
{
fcx
.block_arena
.alloc
(
Block
S
{
llbb
:
llbb
,
terminated
:
Cell
::
new
(
false
),
unreachable
:
Cell
::
new
(
false
),
...
...
@@ -448,11 +450,13 @@ pub fn new(llbb: BasicBlockRef,
})
}
pub
fn
ccx
(
&
self
)
->
&
'a
CrateContext
<
'a
,
'tcx
>
{
self
.fcx.ccx
}
pub
fn
tcx
(
&
self
)
->
&
'a
ty
::
ctxt
<
'tcx
>
{
pub
fn
ccx
(
&
self
)
->
&
'blk
CrateContext
<
'blk
,
'tcx
>
{
self
.fcx.ccx
}
pub
fn
tcx
(
&
self
)
->
&
'blk
ty
::
ctxt
<
'tcx
>
{
self
.fcx.ccx
.tcx
()
}
pub
fn
sess
(
&
self
)
->
&
'
a
Session
{
self
.fcx.ccx
.sess
()
}
pub
fn
sess
(
&
self
)
->
&
'
blk
Session
{
self
.fcx.ccx
.sess
()
}
pub
fn
ident
(
&
self
,
ident
:
Ident
)
->
String
{
token
::
get_ident
(
ident
)
.get
()
.to_string
()
...
...
@@ -489,12 +493,11 @@ pub fn ty_to_string(&self, t: ty::t) -> String {
}
pub
fn
to_str
(
&
self
)
->
String
{
let
blk
:
*
const
Block
=
self
;
format!
(
"[block {}]"
,
blk
)
format!
(
"[block {:p}]"
,
self
)
}
}
impl
<
'blk
,
'tcx
>
mc
::
Typer
<
'tcx
>
for
Block
<
'blk
,
'tcx
>
{
impl
<
'blk
,
'tcx
>
mc
::
Typer
<
'tcx
>
for
Block
S
<
'blk
,
'tcx
>
{
fn
tcx
<
'a
>
(
&
'a
self
)
->
&
'a
ty
::
ctxt
<
'tcx
>
{
self
.tcx
()
}
...
...
@@ -535,12 +538,12 @@ fn capture_mode(&self, closure_expr_id: ast::NodeId)
}
pub
struct
Result
<
'blk
,
'tcx
:
'blk
>
{
pub
bcx
:
&
'blk
Block
<
'blk
,
'tcx
>
,
pub
bcx
:
Block
<
'blk
,
'tcx
>
,
pub
val
:
ValueRef
}
impl
<
'b
,
'tcx
>
Result
<
'b
,
'tcx
>
{
pub
fn
new
(
bcx
:
&
'b
Block
<
'b
,
'tcx
>
,
val
:
ValueRef
)
->
Result
<
'b
,
'tcx
>
{
pub
fn
new
(
bcx
:
Block
<
'b
,
'tcx
>
,
val
:
ValueRef
)
->
Result
<
'b
,
'tcx
>
{
Result
{
bcx
:
bcx
,
val
:
val
,
...
...
@@ -745,21 +748,21 @@ pub fn is_null(val: ValueRef) -> bool {
}
}
pub
fn
monomorphize_type
(
bcx
:
Block
,
t
:
ty
::
t
)
->
ty
::
t
{
pub
fn
monomorphize_type
(
bcx
:
&
BlockS
,
t
:
ty
::
t
)
->
ty
::
t
{
t
.subst
(
bcx
.tcx
(),
&
bcx
.fcx.param_substs.substs
)
}
pub
fn
node_id_type
(
bcx
:
Block
,
id
:
ast
::
NodeId
)
->
ty
::
t
{
pub
fn
node_id_type
(
bcx
:
&
BlockS
,
id
:
ast
::
NodeId
)
->
ty
::
t
{
let
tcx
=
bcx
.tcx
();
let
t
=
ty
::
node_id_to_type
(
tcx
,
id
);
monomorphize_type
(
bcx
,
t
)
}
pub
fn
expr_ty
(
bcx
:
&
Block
,
ex
:
&
ast
::
Expr
)
->
ty
::
t
{
pub
fn
expr_ty
(
bcx
:
Block
,
ex
:
&
ast
::
Expr
)
->
ty
::
t
{
node_id_type
(
bcx
,
ex
.id
)
}
pub
fn
expr_ty_adjusted
(
bcx
:
&
Block
,
ex
:
&
ast
::
Expr
)
->
ty
::
t
{
pub
fn
expr_ty_adjusted
(
bcx
:
Block
,
ex
:
&
ast
::
Expr
)
->
ty
::
t
{
monomorphize_type
(
bcx
,
ty
::
expr_ty_adjusted
(
bcx
.tcx
(),
ex
))
}
...
...
@@ -773,7 +776,7 @@ pub enum ExprOrMethodCall {
MethodCall
(
typeck
::
MethodCall
)
}
pub
fn
node_id_substs
(
bcx
:
&
Block
,
pub
fn
node_id_substs
(
bcx
:
Block
,
node
:
ExprOrMethodCall
)
->
subst
::
Substs
{
let
tcx
=
bcx
.tcx
();
...
...
@@ -798,7 +801,7 @@ pub fn node_id_substs(bcx: &Block,
substs
.substp
(
tcx
,
bcx
.fcx.param_substs
)
}
pub
fn
node_vtables
(
bcx
:
&
Block
,
id
:
typeck
::
MethodCall
)
pub
fn
node_vtables
(
bcx
:
Block
,
id
:
typeck
::
MethodCall
)
->
typeck
::
vtable_res
{
bcx
.tcx
()
.vtable_map
.borrow
()
.find
(
&
id
)
.map
(|
vts
|
{
resolve_vtables_in_fn_ctxt
(
bcx
.fcx
,
vts
)
...
...
@@ -876,7 +879,7 @@ pub fn find_vtable(tcx: &ty::ctxt,
param_bounds
.get
(
n_bound
)
.clone
()
}
pub
fn
langcall
(
bcx
:
&
Block
,
pub
fn
langcall
(
bcx
:
Block
,
span
:
Option
<
Span
>
,
msg
:
&
str
,
li
:
LangItem
)
...
...
src/librustc/middle/trans/controlflow.rs
浏览文件 @
f7a997be
...
...
@@ -41,9 +41,9 @@
use
std
::
gc
::
Gc
;
pub
fn
trans_stmt
<
'
a
>
(
cx
:
&
'a
Block
<
'a
>
,
s
:
&
ast
::
Stmt
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_stmt
<
'
blk
,
'tcx
>
(
cx
:
Block
<
'blk
,
'tcx
>
,
s
:
&
ast
::
Stmt
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"trans_stmt"
);
let
fcx
=
cx
.fcx
;
debug!
(
"trans_stmt({})"
,
s
.repr
(
cx
.tcx
()));
...
...
@@ -83,7 +83,8 @@ pub fn trans_stmt<'a>(cx: &'a Block<'a>,
return
bcx
;
}
pub
fn
trans_stmt_semi
<
'a
>
(
cx
:
&
'a
Block
<
'a
>
,
e
:
&
ast
::
Expr
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_stmt_semi
<
'blk
,
'tcx
>
(
cx
:
Block
<
'blk
,
'tcx
>
,
e
:
&
ast
::
Expr
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"trans_stmt_semi"
);
let
ty
=
expr_ty
(
cx
,
e
);
if
ty
::
type_needs_drop
(
cx
.tcx
(),
ty
)
{
...
...
@@ -93,10 +94,10 @@ pub fn trans_stmt_semi<'a>(cx: &'a Block<'a>, e: &ast::Expr) -> &'a Block<'a> {
}
}
pub
fn
trans_block
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
b
:
&
ast
::
Block
,
mut
dest
:
expr
::
Dest
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_block
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
b
:
&
ast
::
Block
,
mut
dest
:
expr
::
Dest
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"trans_block"
);
let
fcx
=
bcx
.fcx
;
let
mut
bcx
=
bcx
;
...
...
@@ -128,13 +129,13 @@ pub fn trans_block<'a>(bcx: &'a Block<'a>,
return
bcx
;
}
pub
fn
trans_if
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
if_id
:
ast
::
NodeId
,
cond
:
&
ast
::
Expr
,
thn
:
ast
::
P
<
ast
::
Block
>
,
els
:
Option
<
Gc
<
ast
::
Expr
>>
,
dest
:
expr
::
Dest
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_if
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
if_id
:
ast
::
NodeId
,
cond
:
&
ast
::
Expr
,
thn
:
ast
::
P
<
ast
::
Block
>
,
els
:
Option
<
Gc
<
ast
::
Expr
>>
,
dest
:
expr
::
Dest
)
->
Block
<
'blk
,
'tcx
>
{
debug!
(
"trans_if(bcx={}, if_id={}, cond={}, thn={:?}, dest={})"
,
bcx
.to_str
(),
if_id
,
bcx
.expr_to_string
(
cond
),
thn
.id
,
dest
.to_string
(
bcx
.ccx
()));
...
...
@@ -204,11 +205,11 @@ pub fn trans_if<'a>(bcx: &'a Block<'a>,
next_bcx
}
pub
fn
trans_while
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
loop_id
:
ast
::
NodeId
,
cond
:
&
ast
::
Expr
,
body
:
&
ast
::
Block
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_while
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
loop_id
:
ast
::
NodeId
,
cond
:
&
ast
::
Expr
,
body
:
&
ast
::
Block
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"trans_while"
);
let
fcx
=
bcx
.fcx
;
...
...
@@ -248,13 +249,12 @@ pub fn trans_while<'a>(bcx: &'a Block<'a>,
}
/// Translates a `for` loop.
pub
fn
trans_for
<
'a
>
(
mut
bcx
:
&
'a
Block
<
'a
>
,
loop_info
:
NodeInfo
,
pat
:
Gc
<
ast
::
Pat
>
,
head
:
&
ast
::
Expr
,
body
:
&
ast
::
Block
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_for
<
'blk
,
'tcx
>
(
mut
bcx
:
Block
<
'blk
,
'tcx
>
,
loop_info
:
NodeInfo
,
pat
:
Gc
<
ast
::
Pat
>
,
head
:
&
ast
::
Expr
,
body
:
&
ast
::
Block
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"trans_for"
);
// bcx
...
...
@@ -369,10 +369,10 @@ pub fn trans_for<'a>(
next_bcx_in
}
pub
fn
trans_loop
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
loop_id
:
ast
::
NodeId
,
body
:
&
ast
::
Block
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_loop
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
loop_id
:
ast
::
NodeId
,
body
:
&
ast
::
Block
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"trans_loop"
);
let
fcx
=
bcx
.fcx
;
...
...
@@ -405,11 +405,11 @@ pub fn trans_loop<'a>(bcx:&'a Block<'a>,
return
next_bcx_in
;
}
pub
fn
trans_break_cont
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
expr_id
:
ast
::
NodeId
,
opt_label
:
Option
<
Ident
>
,
exit
:
uint
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_break_cont
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
expr_id
:
ast
::
NodeId
,
opt_label
:
Option
<
Ident
>
,
exit
:
uint
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"trans_break_cont"
);
let
fcx
=
bcx
.fcx
;
...
...
@@ -438,23 +438,23 @@ pub fn trans_break_cont<'a>(bcx: &'a Block<'a>,
return
bcx
;
}
pub
fn
trans_break
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
expr_id
:
ast
::
NodeId
,
label_opt
:
Option
<
Ident
>
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_break
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
expr_id
:
ast
::
NodeId
,
label_opt
:
Option
<
Ident
>
)
->
Block
<
'blk
,
'tcx
>
{
return
trans_break_cont
(
bcx
,
expr_id
,
label_opt
,
cleanup
::
EXIT_BREAK
);
}
pub
fn
trans_cont
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
expr_id
:
ast
::
NodeId
,
label_opt
:
Option
<
Ident
>
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_cont
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
expr_id
:
ast
::
NodeId
,
label_opt
:
Option
<
Ident
>
)
->
Block
<
'blk
,
'tcx
>
{
return
trans_break_cont
(
bcx
,
expr_id
,
label_opt
,
cleanup
::
EXIT_LOOP
);
}
pub
fn
trans_ret
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
e
:
Option
<
Gc
<
ast
::
Expr
>>
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_ret
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
e
:
Option
<
Gc
<
ast
::
Expr
>>
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"trans_ret"
);
let
fcx
=
bcx
.fcx
;
let
mut
bcx
=
bcx
;
...
...
@@ -483,11 +483,10 @@ pub fn trans_ret<'a>(bcx: &'a Block<'a>,
return
bcx
;
}
pub
fn
trans_fail
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
sp
:
Span
,
fail_str
:
InternedString
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_fail
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
sp
:
Span
,
fail_str
:
InternedString
)
->
Block
<
'blk
,
'tcx
>
{
let
ccx
=
bcx
.ccx
();
let
_
icx
=
push_ctxt
(
"trans_fail_value"
);
...
...
@@ -508,12 +507,11 @@ pub fn trans_fail<'a>(
return
bcx
;
}
pub
fn
trans_fail_bounds_check
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
sp
:
Span
,
index
:
ValueRef
,
len
:
ValueRef
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_fail_bounds_check
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
sp
:
Span
,
index
:
ValueRef
,
len
:
ValueRef
)
->
Block
<
'blk
,
'tcx
>
{
let
ccx
=
bcx
.ccx
();
let
_
icx
=
push_ctxt
(
"trans_fail_bounds_check"
);
...
...
src/librustc/middle/trans/datum.rs
浏览文件 @
f7a997be
...
...
@@ -47,8 +47,8 @@ pub struct Datum<K> {
pub
kind
:
K
,
}
pub
struct
DatumBlock
<
'
a
,
K
>
{
pub
bcx
:
&
'a
Block
<
'a
>
,
pub
struct
DatumBlock
<
'
blk
,
'tcx
:
'blk
,
K
>
{
pub
bcx
:
Block
<
'blk
,
'tcx
>
,
pub
datum
:
Datum
<
K
>
,
}
...
...
@@ -94,23 +94,23 @@ pub fn immediate_rvalue(val: ValueRef, ty: ty::t) -> Datum<Rvalue> {
return
Datum
::
new
(
val
,
ty
,
Rvalue
::
new
(
ByValue
));
}
pub
fn
immediate_rvalue_bcx
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
val
:
ValueRef
,
ty
:
ty
::
t
)
->
DatumBlock
<
'a
,
Rvalue
>
{
pub
fn
immediate_rvalue_bcx
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
val
:
ValueRef
,
ty
:
ty
::
t
)
->
DatumBlock
<
'blk
,
'tcx
,
Rvalue
>
{
return
DatumBlock
::
new
(
bcx
,
immediate_rvalue
(
val
,
ty
))
}
pub
fn
lvalue_scratch_datum
<
'
a
,
A
>
(
bcx
:
&
'a
Block
<
'a
>
,
ty
:
ty
::
t
,
name
:
&
str
,
zero
:
bool
,
scope
:
cleanup
::
ScopeId
,
arg
:
A
,
populate
:
|
A
,
&
'a
Block
<
'a
>
,
ValueRef
|
->
&
'a
Block
<
'a
>
)
->
DatumBlock
<
'a
,
Lvalue
>
{
pub
fn
lvalue_scratch_datum
<
'
blk
,
'tcx
,
A
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
ty
:
ty
::
t
,
name
:
&
str
,
zero
:
bool
,
scope
:
cleanup
::
ScopeId
,
arg
:
A
,
populate
:
|
A
,
Block
<
'blk
,
'tcx
>
,
ValueRef
|
->
Block
<
'blk
,
'tcx
>
)
->
DatumBlock
<
'blk
,
'tcx
,
Lvalue
>
{
/*!
* Allocates temporary space on the stack using alloca() and
* returns a by-ref Datum pointing to it. The memory will be
...
...
@@ -135,7 +135,7 @@ pub fn lvalue_scratch_datum<'a, A>(bcx: &'a Block<'a>,
DatumBlock
::
new
(
bcx
,
Datum
::
new
(
scratch
,
ty
,
Lvalue
))
}
pub
fn
rvalue_scratch_datum
(
bcx
:
&
Block
,
pub
fn
rvalue_scratch_datum
(
bcx
:
Block
,
ty
:
ty
::
t
,
name
:
&
str
)
->
Datum
<
Rvalue
>
{
...
...
@@ -188,11 +188,11 @@ pub trait KindOps {
* Take appropriate action after the value in `datum` has been
* stored to a new location.
*/
fn
post_store
<
'
a
>
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
,
val
:
ValueRef
,
ty
:
ty
::
t
)
->
&
'a
Block
<
'a
>
;
fn
post_store
<
'
blk
,
'tcx
>
(
&
self
,
bcx
:
Block
<
'blk
,
'tcx
>
,
val
:
ValueRef
,
ty
:
ty
::
t
)
->
Block
<
'blk
,
'tcx
>
;
/**
* True if this mode is a reference mode, meaning that the datum's
...
...
@@ -208,11 +208,11 @@ fn post_store<'a>(&self,
}
impl
KindOps
for
Rvalue
{
fn
post_store
<
'
a
>
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
,
_
val
:
ValueRef
,
_
ty
:
ty
::
t
)
->
&
'a
Block
<
'a
>
{
fn
post_store
<
'
blk
,
'tcx
>
(
&
self
,
bcx
:
Block
<
'blk
,
'tcx
>
,
_
val
:
ValueRef
,
_
ty
:
ty
::
t
)
->
Block
<
'blk
,
'tcx
>
{
// No cleanup is scheduled for an rvalue, so we don't have
// to do anything after a move to cancel or duplicate it.
bcx
...
...
@@ -228,11 +228,11 @@ fn to_expr_kind(self) -> Expr {
}
impl
KindOps
for
Lvalue
{
fn
post_store
<
'
a
>
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
,
val
:
ValueRef
,
ty
:
ty
::
t
)
->
&
'a
Block
<
'a
>
{
fn
post_store
<
'
blk
,
'tcx
>
(
&
self
,
bcx
:
Block
<
'blk
,
'tcx
>
,
val
:
ValueRef
,
ty
:
ty
::
t
)
->
Block
<
'blk
,
'tcx
>
{
/*!
* If an lvalue is moved, we must zero out the memory in which
* it resides so as to cancel cleanup. If an @T lvalue is
...
...
@@ -263,11 +263,11 @@ fn to_expr_kind(self) -> Expr {
}
impl
KindOps
for
Expr
{
fn
post_store
<
'
a
>
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
,
val
:
ValueRef
,
ty
:
ty
::
t
)
->
&
'a
Block
<
'a
>
{
fn
post_store
<
'
blk
,
'tcx
>
(
&
self
,
bcx
:
Block
<
'blk
,
'tcx
>
,
val
:
ValueRef
,
ty
:
ty
::
t
)
->
Block
<
'blk
,
'tcx
>
{
match
*
self
{
LvalueExpr
=>
Lvalue
.post_store
(
bcx
,
val
,
ty
),
RvalueExpr
(
ref
r
)
=>
r
.post_store
(
bcx
,
val
,
ty
),
...
...
@@ -302,11 +302,11 @@ pub fn add_clean(self,
self
.val
}
pub
fn
to_lvalue_datum_in_scope
<
'
a
>
(
self
,
bcx
:
&
'a
Block
<
'a
>
,
name
:
&
str
,
scope
:
cleanup
::
ScopeId
)
->
DatumBlock
<
'a
,
Lvalue
>
{
pub
fn
to_lvalue_datum_in_scope
<
'
blk
,
'tcx
>
(
self
,
bcx
:
Block
<
'blk
,
'tcx
>
,
name
:
&
str
,
scope
:
cleanup
::
ScopeId
)
->
DatumBlock
<
'blk
,
'tcx
,
Lvalue
>
{
/*!
* Returns an lvalue datum (that is, a by ref datum with
* cleanup scheduled). If `self` is not already an lvalue,
...
...
@@ -328,7 +328,8 @@ pub fn to_lvalue_datum_in_scope<'a>(self,
}
}
pub
fn
to_ref_datum
<
'a
>
(
self
,
bcx
:
&
'a
Block
<
'a
>
)
->
DatumBlock
<
'a
,
Rvalue
>
{
pub
fn
to_ref_datum
<
'blk
,
'tcx
>
(
self
,
bcx
:
Block
<
'blk
,
'tcx
>
)
->
DatumBlock
<
'blk
,
'tcx
,
Rvalue
>
{
let
mut
bcx
=
bcx
;
match
self
.kind.mode
{
ByRef
=>
DatumBlock
::
new
(
bcx
,
self
),
...
...
@@ -340,9 +341,9 @@ pub fn to_ref_datum<'a>(self, bcx: &'a Block<'a>) -> DatumBlock<'a, Rvalue> {
}
}
pub
fn
to_appropriate_datum
<
'
a
>
(
self
,
bcx
:
&
'a
Block
<
'a
>
)
->
DatumBlock
<
'a
,
Rvalue
>
{
pub
fn
to_appropriate_datum
<
'
blk
,
'tcx
>
(
self
,
bcx
:
Block
<
'blk
,
'tcx
>
)
->
DatumBlock
<
'blk
,
'tcx
,
Rvalue
>
{
match
self
.appropriate_rvalue_mode
(
bcx
.ccx
())
{
ByRef
=>
{
self
.to_ref_datum
(
bcx
)
...
...
@@ -381,7 +382,7 @@ fn match_kind<R>(self,
}
#[allow(dead_code)]
// potentially useful
pub
fn
assert_lvalue
(
self
,
bcx
:
&
Block
)
->
Datum
<
Lvalue
>
{
pub
fn
assert_lvalue
(
self
,
bcx
:
Block
)
->
Datum
<
Lvalue
>
{
/*!
* Asserts that this datum *is* an lvalue and returns it.
*/
...
...
@@ -391,7 +392,7 @@ pub fn assert_lvalue(self, bcx: &Block) -> Datum<Lvalue> {
|
_
|
bcx
.sess
()
.bug
(
"assert_lvalue given rvalue"
))
}
pub
fn
assert_rvalue
(
self
,
bcx
:
&
Block
)
->
Datum
<
Rvalue
>
{
pub
fn
assert_rvalue
(
self
,
bcx
:
Block
)
->
Datum
<
Rvalue
>
{
/*!
* Asserts that this datum *is* an lvalue and returns it.
*/
...
...
@@ -401,11 +402,11 @@ pub fn assert_rvalue(self, bcx: &Block) -> Datum<Rvalue> {
|
r
|
r
)
}
pub
fn
store_to_dest
<
'
a
>
(
self
,
bcx
:
&
'a
Block
<
'a
>
,
dest
:
expr
::
Dest
,
expr_id
:
ast
::
NodeId
)
->
&
'a
Block
<
'a
>
{
pub
fn
store_to_dest
<
'
blk
,
'tcx
>
(
self
,
bcx
:
Block
<
'blk
,
'tcx
>
,
dest
:
expr
::
Dest
,
expr_id
:
ast
::
NodeId
)
->
Block
<
'blk
,
'tcx
>
{
match
dest
{
expr
::
Ignore
=>
{
self
.add_clean_if_rvalue
(
bcx
,
expr_id
);
...
...
@@ -417,9 +418,9 @@ pub fn store_to_dest<'a>(self,
}
}
pub
fn
add_clean_if_rvalue
<
'
a
>
(
self
,
bcx
:
&
'a
Block
<
'a
>
,
expr_id
:
ast
::
NodeId
)
{
pub
fn
add_clean_if_rvalue
<
'
blk
,
'tcx
>
(
self
,
bcx
:
Block
<
'blk
,
'tcx
>
,
expr_id
:
ast
::
NodeId
)
{
/*!
* Arranges cleanup for `self` if it is an rvalue. Use when
* you are done working with a value that may need drop.
...
...
@@ -433,11 +434,11 @@ pub fn add_clean_if_rvalue<'a>(self,
})
}
pub
fn
clean
<
'
a
>
(
self
,
bcx
:
&
'a
Block
<
'a
>
,
name
:
&
'static
str
,
expr_id
:
ast
::
NodeId
)
->
&
'a
Block
<
'a
>
{
pub
fn
clean
<
'
blk
,
'tcx
>
(
self
,
bcx
:
Block
<
'blk
,
'tcx
>
,
name
:
&
'static
str
,
expr_id
:
ast
::
NodeId
)
->
Block
<
'blk
,
'tcx
>
{
/*!
* Ensures that `self` will get cleaned up, if it is not an lvalue
* already.
...
...
@@ -446,11 +447,11 @@ pub fn clean<'a>(self,
self
.to_lvalue_datum
(
bcx
,
name
,
expr_id
)
.bcx
}
pub
fn
to_lvalue_datum
<
'
a
>
(
self
,
bcx
:
&
'a
Block
<
'a
>
,
name
:
&
str
,
expr_id
:
ast
::
NodeId
)
->
DatumBlock
<
'a
,
Lvalue
>
{
pub
fn
to_lvalue_datum
<
'
blk
,
'tcx
>
(
self
,
bcx
:
Block
<
'blk
,
'tcx
>
,
name
:
&
str
,
expr_id
:
ast
::
NodeId
)
->
DatumBlock
<
'blk
,
'tcx
,
Lvalue
>
{
debug!
(
"to_lvalue_datum self: {}"
,
self
.to_string
(
bcx
.ccx
()));
assert
!
(
ty
::
lltype_is_sized
(
bcx
.tcx
(),
self
.ty
),
...
...
@@ -463,10 +464,10 @@ pub fn to_lvalue_datum<'a>(self,
})
}
pub
fn
to_rvalue_datum
<
'
a
>
(
self
,
bcx
:
&
'a
Block
<
'a
>
,
name
:
&
'static
str
)
->
DatumBlock
<
'a
,
Rvalue
>
{
pub
fn
to_rvalue_datum
<
'
blk
,
'tcx
>
(
self
,
bcx
:
Block
<
'blk
,
'tcx
>
,
name
:
&
'static
str
)
->
DatumBlock
<
'blk
,
'tcx
,
Rvalue
>
{
/*!
* Ensures that we have an rvalue datum (that is, a datum with
* no cleanup scheduled).
...
...
@@ -514,11 +515,9 @@ pub fn to_llref(self) -> ValueRef {
// datum may also be unsized _without the size information_. It is the
// callers responsibility to package the result in some way to make a valid
// datum in that case (e.g., by making a fat pointer or opened pair).
pub
fn
get_element
<
'a
>
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
,
ty
:
ty
::
t
,
gep
:
|
ValueRef
|
->
ValueRef
)
->
Datum
<
Lvalue
>
{
pub
fn
get_element
(
&
self
,
bcx
:
Block
,
ty
:
ty
::
t
,
gep
:
|
ValueRef
|
->
ValueRef
)
->
Datum
<
Lvalue
>
{
let
val
=
match
ty
::
get
(
self
.ty
)
.sty
{
_
if
ty
::
type_is_sized
(
bcx
.tcx
(),
self
.ty
)
=>
gep
(
self
.val
),
ty
::
ty_open
(
_
)
=>
{
...
...
@@ -536,7 +535,7 @@ pub fn get_element<'a>(&self,
}
}
pub
fn
get_vec_base_and_len
<
'a
>
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
)
->
(
ValueRef
,
ValueRef
)
{
pub
fn
get_vec_base_and_len
(
&
self
,
bcx
:
Block
)
->
(
ValueRef
,
ValueRef
)
{
//! Converts a vector into the slice pair.
tvec
::
get_base_and_len
(
bcx
,
self
.val
,
self
.ty
)
...
...
@@ -556,10 +555,10 @@ pub fn to_expr_datum(self) -> Datum<Expr> {
Datum
{
val
:
val
,
ty
:
ty
,
kind
:
kind
.to_expr_kind
()
}
}
pub
fn
store_to
<
'
a
>
(
self
,
bcx
:
&
'a
Block
<
'a
>
,
dst
:
ValueRef
)
->
&
'a
Block
<
'a
>
{
pub
fn
store_to
<
'
blk
,
'tcx
>
(
self
,
bcx
:
Block
<
'blk
,
'tcx
>
,
dst
:
ValueRef
)
->
Block
<
'blk
,
'tcx
>
{
/*!
* Moves or copies this value into a new home, as appropriate
* depending on the type of the datum. This method consumes
...
...
@@ -573,10 +572,10 @@ pub fn store_to<'a>(self,
self
.kind
.post_store
(
bcx
,
self
.val
,
self
.ty
)
}
fn
shallow_copy
<
'
a
>
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
,
dst
:
ValueRef
)
->
&
'a
Block
<
'a
>
{
fn
shallow_copy
<
'
blk
,
'tcx
>
(
&
self
,
bcx
:
Block
<
'blk
,
'tcx
>
,
dst
:
ValueRef
)
->
Block
<
'blk
,
'tcx
>
{
/*!
* Helper function that performs a shallow copy of this value
* into `dst`, which should be a pointer to a memory location
...
...
@@ -606,10 +605,10 @@ fn shallow_copy<'a>(&self,
return
bcx
;
}
pub
fn
shallow_copy_and_take
<
'
a
>
(
&
self
,
bcx
:
&
'a
Block
<
'a
>
,
dst
:
ValueRef
)
->
&
'a
Block
<
'a
>
{
pub
fn
shallow_copy_and_take
<
'
blk
,
'tcx
>
(
&
self
,
bcx
:
Block
<
'blk
,
'tcx
>
,
dst
:
ValueRef
)
->
Block
<
'blk
,
'tcx
>
{
/*!
* Copies the value into a new location and runs any necessary
* take glue on the new location. This function always
...
...
@@ -638,7 +637,7 @@ pub fn appropriate_rvalue_mode(&self, ccx: &CrateContext) -> RvalueMode {
appropriate_rvalue_mode
(
ccx
,
self
.ty
)
}
pub
fn
to_llscalarish
<
'a
>
(
self
,
bcx
:
&
'a
Block
<
'a
>
)
->
ValueRef
{
pub
fn
to_llscalarish
(
self
,
bcx
:
Block
)
->
ValueRef
{
/*!
* Converts `self` into a by-value `ValueRef`. Consumes this
* datum (i.e., absolves you of responsibility to cleanup the
...
...
@@ -657,33 +656,33 @@ pub fn to_llscalarish<'a>(self, bcx: &'a Block<'a>) -> ValueRef {
}
}
pub
fn
to_llbool
<
'a
>
(
self
,
bcx
:
&
'a
Block
<
'a
>
)
->
ValueRef
{
pub
fn
to_llbool
(
self
,
bcx
:
Block
)
->
ValueRef
{
assert
!
(
ty
::
type_is_bool
(
self
.ty
)
||
ty
::
type_is_bot
(
self
.ty
))
self
.to_llscalarish
(
bcx
)
}
}
impl
<
'a
,
K
>
DatumBlock
<
'a
,
K
>
{
pub
fn
new
(
bcx
:
&
'a
Block
<
'a
>
,
datum
:
Datum
<
K
>
)
->
DatumBlock
<
'a
,
K
>
{
impl
<
'blk
,
'tcx
,
K
>
DatumBlock
<
'blk
,
'tcx
,
K
>
{
pub
fn
new
(
bcx
:
Block
<
'blk
,
'tcx
>
,
datum
:
Datum
<
K
>
)
->
DatumBlock
<
'blk
,
'tcx
,
K
>
{
DatumBlock
{
bcx
:
bcx
,
datum
:
datum
}
}
}
impl
<
'
a
,
K
:
KindOps
>
DatumBlock
<
'a
,
K
>
{
pub
fn
to_expr_datumblock
(
self
)
->
DatumBlock
<
'
a
,
Expr
>
{
impl
<
'
blk
,
'tcx
,
K
:
KindOps
>
DatumBlock
<
'blk
,
'tcx
,
K
>
{
pub
fn
to_expr_datumblock
(
self
)
->
DatumBlock
<
'
blk
,
'tcx
,
Expr
>
{
DatumBlock
::
new
(
self
.bcx
,
self
.datum
.to_expr_datum
())
}
}
impl
<
'
a
>
DatumBlock
<
'a
,
Expr
>
{
impl
<
'
blk
,
'tcx
>
DatumBlock
<
'blk
,
'tcx
,
Expr
>
{
pub
fn
store_to_dest
(
self
,
dest
:
expr
::
Dest
,
expr_id
:
ast
::
NodeId
)
->
&
'a
Block
<
'a
>
{
expr_id
:
ast
::
NodeId
)
->
Block
<
'blk
,
'tcx
>
{
let
DatumBlock
{
bcx
,
datum
}
=
self
;
datum
.store_to_dest
(
bcx
,
dest
,
expr_id
)
}
pub
fn
to_llbool
(
self
)
->
Result
<
'
a
>
{
pub
fn
to_llbool
(
self
)
->
Result
<
'
blk
,
'tcx
>
{
let
DatumBlock
{
datum
,
bcx
}
=
self
;
Result
::
new
(
bcx
,
datum
.to_llbool
(
bcx
))
}
...
...
src/librustc/middle/trans/debuginfo.rs
浏览文件 @
f7a997be
...
...
@@ -832,7 +832,7 @@ pub fn create_global_var_metadata(cx: &CrateContext,
/// Creates debug information for the given local variable.
///
/// Adds the created metadata nodes directly to the crate's IR.
pub
fn
create_local_var_metadata
(
bcx
:
&
Block
,
local
:
&
ast
::
Local
)
{
pub
fn
create_local_var_metadata
(
bcx
:
Block
,
local
:
&
ast
::
Local
)
{
if
fn_should_be_ignored
(
bcx
.fcx
)
{
return
;
}
...
...
@@ -867,7 +867,7 @@ pub fn create_local_var_metadata(bcx: &Block, local: &ast::Local) {
/// Creates debug information for a variable captured in a closure.
///
/// Adds the created metadata nodes directly to the crate's IR.
pub
fn
create_captured_var_metadata
(
bcx
:
&
Block
,
pub
fn
create_captured_var_metadata
(
bcx
:
Block
,
node_id
:
ast
::
NodeId
,
env_data_type
:
ty
::
t
,
env_pointer
:
ValueRef
,
...
...
@@ -954,7 +954,7 @@ pub fn create_captured_var_metadata(bcx: &Block,
/// match-statement arm.
///
/// Adds the created metadata nodes directly to the crate's IR.
pub
fn
create_match_binding_metadata
(
bcx
:
&
Block
,
pub
fn
create_match_binding_metadata
(
bcx
:
Block
,
variable_ident
:
ast
::
Ident
,
binding
:
BindingInfo
)
{
if
fn_should_be_ignored
(
bcx
.fcx
)
{
...
...
@@ -994,7 +994,7 @@ pub fn create_match_binding_metadata(bcx: &Block,
/// Creates debug information for the given function argument.
///
/// Adds the created metadata nodes directly to the crate's IR.
pub
fn
create_argument_metadata
(
bcx
:
&
Block
,
arg
:
&
ast
::
Arg
)
{
pub
fn
create_argument_metadata
(
bcx
:
Block
,
arg
:
&
ast
::
Arg
)
{
if
fn_should_be_ignored
(
bcx
.fcx
)
{
return
;
}
...
...
@@ -1518,7 +1518,7 @@ fn fallback_path(cx: &CrateContext) -> CString {
}
}
fn
declare_local
(
bcx
:
&
Block
,
fn
declare_local
(
bcx
:
Block
,
variable_ident
:
ast
::
Ident
,
variable_type
:
ty
::
t
,
scope_metadata
:
DIScope
,
...
...
src/librustc/middle/trans/expr.rs
浏览文件 @
f7a997be
此差异已折叠。
点击以展开。
src/librustc/middle/trans/foreign.rs
浏览文件 @
f7a997be
...
...
@@ -247,14 +247,13 @@ pub fn register_foreign_item_fn(ccx: &CrateContext, abi: Abi, fty: ty::t,
llfn
}
pub
fn
trans_native_call
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
callee_ty
:
ty
::
t
,
llfn
:
ValueRef
,
llretptr
:
ValueRef
,
llargs_rust
:
&
[
ValueRef
],
passed_arg_tys
:
Vec
<
ty
::
t
>
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_native_call
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
callee_ty
:
ty
::
t
,
llfn
:
ValueRef
,
llretptr
:
ValueRef
,
llargs_rust
:
&
[
ValueRef
],
passed_arg_tys
:
Vec
<
ty
::
t
>
)
->
Block
<
'blk
,
'tcx
>
{
/*!
* Prepares a call to a native function. This requires adapting
* from the Rust argument passing rules to the native rules.
...
...
src/librustc/middle/trans/glue.rs
浏览文件 @
f7a997be
...
...
@@ -45,7 +45,8 @@
use
syntax
::
ast
;
use
syntax
::
parse
::
token
;
pub
fn
trans_free
<
'a
>
(
cx
:
&
'a
Block
<
'a
>
,
v
:
ValueRef
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_free
<
'blk
,
'tcx
>
(
cx
:
Block
<
'blk
,
'tcx
>
,
v
:
ValueRef
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"trans_free"
);
callee
::
trans_lang_call
(
cx
,
langcall
(
cx
,
None
,
""
,
FreeFnLangItem
),
...
...
@@ -53,8 +54,9 @@ pub fn trans_free<'a>(cx: &'a Block<'a>, v: ValueRef) -> &'a Block<'a> {
Some
(
expr
::
Ignore
))
.bcx
}
pub
fn
trans_exchange_free_dyn
<
'a
>
(
cx
:
&
'a
Block
<
'a
>
,
v
:
ValueRef
,
size
:
ValueRef
,
align
:
ValueRef
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_exchange_free_dyn
<
'blk
,
'tcx
>
(
cx
:
Block
<
'blk
,
'tcx
>
,
v
:
ValueRef
,
size
:
ValueRef
,
align
:
ValueRef
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"trans_exchange_free"
);
let
ccx
=
cx
.ccx
();
callee
::
trans_lang_call
(
cx
,
...
...
@@ -63,14 +65,14 @@ pub fn trans_exchange_free_dyn<'a>(cx: &'a Block<'a>, v: ValueRef, size: ValueRe
Some
(
expr
::
Ignore
))
.bcx
}
pub
fn
trans_exchange_free
<
'
a
>
(
cx
:
&
'a
Block
<
'a
>
,
v
:
ValueRef
,
size
:
u64
,
align
:
u64
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_exchange_free
<
'
blk
,
'tcx
>
(
cx
:
Block
<
'blk
,
'tcx
>
,
v
:
ValueRef
,
size
:
u64
,
align
:
u64
)
->
Block
<
'blk
,
'tcx
>
{
trans_exchange_free_dyn
(
cx
,
v
,
C_uint
(
cx
.ccx
(),
size
as
uint
),
C_uint
(
cx
.ccx
(),
align
as
uint
))
}
pub
fn
trans_exchange_free_ty
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
ptr
:
ValueRef
,
content_ty
:
ty
::
t
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_exchange_free_ty
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
ptr
:
ValueRef
,
content_ty
:
ty
::
t
)
->
Block
<
'blk
,
'tcx
>
{
assert
!
(
ty
::
type_is_sized
(
bcx
.ccx
()
.tcx
(),
content_ty
));
let
sizing_type
=
sizing_type_of
(
bcx
.ccx
(),
content_ty
);
let
content_size
=
llsize_of_alloc
(
bcx
.ccx
(),
sizing_type
);
...
...
@@ -84,8 +86,8 @@ pub fn trans_exchange_free_ty<'a>(bcx: &'a Block<'a>, ptr: ValueRef,
}
}
pub
fn
take_ty
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
v
:
ValueRef
,
t
:
ty
::
t
)
->
&
'a
Block
<
'a
>
{
pub
fn
take_ty
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
v
:
ValueRef
,
t
:
ty
::
t
)
->
Block
<
'blk
,
'tcx
>
{
// NB: v is an *alias* of type t here, not a direct value.
let
_
icx
=
push_ctxt
(
"take_ty"
);
match
ty
::
get
(
t
)
.sty
{
...
...
@@ -123,8 +125,8 @@ pub fn get_drop_glue_type(ccx: &CrateContext, t: ty::t) -> ty::t {
}
}
pub
fn
drop_ty
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
v
:
ValueRef
,
t
:
ty
::
t
)
->
&
'a
Block
<
'a
>
{
pub
fn
drop_ty
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
v
:
ValueRef
,
t
:
ty
::
t
)
->
Block
<
'blk
,
'tcx
>
{
// NB: v is an *alias* of type t here, not a direct value.
debug!
(
"drop_ty(t={})"
,
t
.repr
(
bcx
.tcx
()));
let
_
icx
=
push_ctxt
(
"drop_ty"
);
...
...
@@ -142,8 +144,8 @@ pub fn drop_ty<'a>(bcx: &'a Block<'a>, v: ValueRef, t: ty::t)
bcx
}
pub
fn
drop_ty_immediate
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
v
:
ValueRef
,
t
:
ty
::
t
)
->
&
'a
Block
<
'a
>
{
pub
fn
drop_ty_immediate
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
v
:
ValueRef
,
t
:
ty
::
t
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"drop_ty_immediate"
);
let
vp
=
alloca
(
bcx
,
type_of
(
bcx
.ccx
(),
t
),
""
);
Store
(
bcx
,
v
,
vp
);
...
...
@@ -232,7 +234,7 @@ pub fn lazily_emit_visit_glue(ccx: &CrateContext, ti: &tydesc_info) -> ValueRef
}
// See [Note-arg-mode]
pub
fn
call_visit_glue
(
bcx
:
&
Block
,
v
:
ValueRef
,
tydesc
:
ValueRef
)
{
pub
fn
call_visit_glue
(
bcx
:
Block
,
v
:
ValueRef
,
tydesc
:
ValueRef
)
{
let
_
icx
=
push_ctxt
(
"call_visit_glue"
);
// Select the glue function to call from the tydesc
...
...
@@ -242,8 +244,8 @@ pub fn call_visit_glue(bcx: &Block, v: ValueRef, tydesc: ValueRef) {
Call
(
bcx
,
llfn
,
[
llrawptr
],
None
);
}
fn
make_visit_glue
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
v
:
ValueRef
,
t
:
ty
::
t
)
->
&
'a
Block
<
'a
>
{
fn
make_visit_glue
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
v
:
ValueRef
,
t
:
ty
::
t
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"make_visit_glue"
);
let
mut
bcx
=
bcx
;
let
(
visitor_trait
,
object_ty
)
=
match
ty
::
visitor_object_ty
(
bcx
.tcx
(),
...
...
@@ -259,13 +261,13 @@ fn make_visit_glue<'a>(bcx: &'a Block<'a>, v: ValueRef, t: ty::t)
bcx
}
fn
trans_struct_drop_flag
<
'
a
>
(
mut
bcx
:
&
'a
Block
<
'a
>
,
t
:
ty
::
t
,
v0
:
ValueRef
,
dtor_did
:
ast
::
DefId
,
class_did
:
ast
::
DefId
,
substs
:
&
subst
::
Substs
)
->
&
'a
Block
<
'a
>
{
fn
trans_struct_drop_flag
<
'
blk
,
'tcx
>
(
mut
bcx
:
Block
<
'blk
,
'tcx
>
,
t
:
ty
::
t
,
v0
:
ValueRef
,
dtor_did
:
ast
::
DefId
,
class_did
:
ast
::
DefId
,
substs
:
&
subst
::
Substs
)
->
Block
<
'blk
,
'tcx
>
{
let
repr
=
adt
::
represent_type
(
bcx
.ccx
(),
t
);
let
struct_data
=
if
ty
::
type_is_sized
(
bcx
.tcx
(),
t
)
{
v0
...
...
@@ -279,13 +281,13 @@ fn trans_struct_drop_flag<'a>(mut bcx: &'a Block<'a>,
})
}
fn
trans_struct_drop
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
t
:
ty
::
t
,
v0
:
ValueRef
,
dtor_did
:
ast
::
DefId
,
class_did
:
ast
::
DefId
,
substs
:
&
subst
::
Substs
)
->
&
'a
Block
<
'a
>
{
fn
trans_struct_drop
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
t
:
ty
::
t
,
v0
:
ValueRef
,
dtor_did
:
ast
::
DefId
,
class_did
:
ast
::
DefId
,
substs
:
&
subst
::
Substs
)
->
Block
<
'blk
,
'tcx
>
{
let
repr
=
adt
::
represent_type
(
bcx
.ccx
(),
t
);
// Find and call the actual destructor
...
...
@@ -371,7 +373,7 @@ fn trans_struct_drop<'a>(bcx: &'a Block<'a>,
})
}
fn
size_and_align_of_dst
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
t
:
ty
::
t
,
info
:
ValueRef
)
->
(
ValueRef
,
ValueRef
)
{
fn
size_and_align_of_dst
(
bcx
:
Block
,
t
:
ty
::
t
,
info
:
ValueRef
)
->
(
ValueRef
,
ValueRef
)
{
debug!
(
"calculate size of DST: {}; with lost info: {}"
,
bcx
.ty_to_string
(
t
),
bcx
.val_to_string
(
info
));
if
ty
::
type_is_sized
(
bcx
.tcx
(),
t
)
{
...
...
@@ -426,7 +428,8 @@ fn size_and_align_of_dst<'a>(bcx: &'a Block<'a>, t :ty::t, info: ValueRef) -> (V
}
}
fn
make_drop_glue
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
v0
:
ValueRef
,
t
:
ty
::
t
)
->
&
'a
Block
<
'a
>
{
fn
make_drop_glue
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
v0
:
ValueRef
,
t
:
ty
::
t
)
->
Block
<
'blk
,
'tcx
>
{
// NB: v0 is an *alias* of type t here, not a direct value.
let
_
icx
=
push_ctxt
(
"make_drop_glue"
);
match
ty
::
get
(
t
)
.sty
{
...
...
@@ -549,9 +552,9 @@ fn make_drop_glue<'a>(bcx: &'a Block<'a>, v0: ValueRef, t: ty::t) -> &'a Block<'
}
}
fn
decr_refcnt_maybe_free
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
box_ptr_ptr
:
ValueRef
,
t
:
ty
::
t
)
->
&
'a
Block
<
'a
>
{
fn
decr_refcnt_maybe_free
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
box_ptr_ptr
:
ValueRef
,
t
:
ty
::
t
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"decr_refcnt_maybe_free"
);
let
fcx
=
bcx
.fcx
;
let
ccx
=
bcx
.ccx
();
...
...
@@ -578,8 +581,8 @@ fn decr_refcnt_maybe_free<'a>(bcx: &'a Block<'a>,
next_bcx
}
fn
incr_refcnt_of_boxed
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
box_ptr_ptr
:
ValueRef
)
->
&
'a
Block
<
'a
>
{
fn
incr_refcnt_of_boxed
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
box_ptr_ptr
:
ValueRef
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"incr_refcnt_of_boxed"
);
let
ccx
=
bcx
.ccx
();
let
box_ptr
=
Load
(
bcx
,
box_ptr_ptr
);
...
...
@@ -645,8 +648,8 @@ fn declare_generic_glue(ccx: &CrateContext, t: ty::t, llfnty: Type,
fn
make_generic_glue
(
ccx
:
&
CrateContext
,
t
:
ty
::
t
,
llfn
:
ValueRef
,
helper
:
<
'
a
>
|
&
'a
Block
<
'a
>
,
ValueRef
,
ty
::
t
|
->
&
'a
Block
<
'a
>
,
helper
:
<
'
blk
,
'tcx
>
|
Block
<
'blk
,
'tcx
>
,
ValueRef
,
ty
::
t
|
->
Block
<
'blk
,
'tcx
>
,
name
:
&
str
)
->
ValueRef
{
let
_
icx
=
push_ctxt
(
"make_generic_glue"
);
...
...
src/librustc/middle/trans/intrinsic.rs
浏览文件 @
f7a997be
...
...
@@ -134,10 +134,11 @@ pub fn check_intrinsics(ccx: &CrateContext) {
ccx
.sess
()
.abort_if_errors
();
}
pub
fn
trans_intrinsic_call
<
'a
>
(
mut
bcx
:
&
'a
Block
<
'a
>
,
node
:
ast
::
NodeId
,
callee_ty
:
ty
::
t
,
cleanup_scope
:
cleanup
::
CustomScopeIndex
,
args
:
callee
::
CallArgs
,
dest
:
expr
::
Dest
,
substs
:
subst
::
Substs
,
call_info
:
NodeInfo
)
->
Result
<
'a
>
{
pub
fn
trans_intrinsic_call
<
'blk
,
'tcx
>
(
mut
bcx
:
Block
<
'blk
,
'tcx
>
,
node
:
ast
::
NodeId
,
callee_ty
:
ty
::
t
,
cleanup_scope
:
cleanup
::
CustomScopeIndex
,
args
:
callee
::
CallArgs
,
dest
:
expr
::
Dest
,
substs
:
subst
::
Substs
,
call_info
:
NodeInfo
)
->
Result
<
'blk
,
'tcx
>
{
let
fcx
=
bcx
.fcx
;
let
ccx
=
fcx
.ccx
;
...
...
@@ -548,7 +549,7 @@ pub fn trans_intrinsic_call<'a>(mut bcx: &'a Block<'a>, node: ast::NodeId,
Result
::
new
(
bcx
,
llresult
)
}
fn
copy_intrinsic
(
bcx
:
&
Block
,
allow_overlap
:
bool
,
volatile
:
bool
,
fn
copy_intrinsic
(
bcx
:
Block
,
allow_overlap
:
bool
,
volatile
:
bool
,
tp_ty
:
ty
::
t
,
dst
:
ValueRef
,
src
:
ValueRef
,
count
:
ValueRef
)
->
ValueRef
{
let
ccx
=
bcx
.ccx
();
let
lltp_ty
=
type_of
::
type_of
(
ccx
,
tp_ty
);
...
...
@@ -577,7 +578,7 @@ fn copy_intrinsic(bcx: &Block, allow_overlap: bool, volatile: bool,
C_bool
(
ccx
,
volatile
)],
None
)
}
fn
memset_intrinsic
(
bcx
:
&
Block
,
volatile
:
bool
,
tp_ty
:
ty
::
t
,
fn
memset_intrinsic
(
bcx
:
Block
,
volatile
:
bool
,
tp_ty
:
ty
::
t
,
dst
:
ValueRef
,
val
:
ValueRef
,
count
:
ValueRef
)
->
ValueRef
{
let
ccx
=
bcx
.ccx
();
let
lltp_ty
=
type_of
::
type_of
(
ccx
,
tp_ty
);
...
...
@@ -596,13 +597,13 @@ fn memset_intrinsic(bcx: &Block, volatile: bool, tp_ty: ty::t,
C_bool
(
ccx
,
volatile
)],
None
)
}
fn
count_zeros_intrinsic
(
bcx
:
&
Block
,
name
:
&
'static
str
,
val
:
ValueRef
)
->
ValueRef
{
fn
count_zeros_intrinsic
(
bcx
:
Block
,
name
:
&
'static
str
,
val
:
ValueRef
)
->
ValueRef
{
let
y
=
C_bool
(
bcx
.ccx
(),
false
);
let
llfn
=
bcx
.ccx
()
.get_intrinsic
(
&
name
);
Call
(
bcx
,
llfn
,
[
val
,
y
],
None
)
}
fn
with_overflow_intrinsic
(
bcx
:
&
Block
,
name
:
&
'static
str
,
t
:
ty
::
t
,
fn
with_overflow_intrinsic
(
bcx
:
Block
,
name
:
&
'static
str
,
t
:
ty
::
t
,
a
:
ValueRef
,
b
:
ValueRef
)
->
ValueRef
{
let
llfn
=
bcx
.ccx
()
.get_intrinsic
(
&
name
);
...
...
src/librustc/middle/trans/meth.rs
浏览文件 @
f7a997be
...
...
@@ -102,12 +102,11 @@ pub fn trans_impl(ccx: &CrateContext,
}
}
pub
fn
trans_method_callee
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
method_call
:
MethodCall
,
self_expr
:
Option
<&
ast
::
Expr
>
,
arg_cleanup_scope
:
cleanup
::
ScopeId
)
->
Callee
<
'a
>
{
pub
fn
trans_method_callee
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
method_call
:
MethodCall
,
self_expr
:
Option
<&
ast
::
Expr
>
,
arg_cleanup_scope
:
cleanup
::
ScopeId
)
->
Callee
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"meth::trans_method_callee"
);
let
(
origin
,
method_ty
)
=
match
bcx
.tcx
()
.method_map
...
...
@@ -166,7 +165,7 @@ pub fn trans_method_callee<'a>(
}
}
pub
fn
trans_static_method_callee
(
bcx
:
&
Block
,
pub
fn
trans_static_method_callee
(
bcx
:
Block
,
method_id
:
ast
::
DefId
,
trait_id
:
ast
::
DefId
,
expr_id
:
ast
::
NodeId
)
...
...
@@ -262,13 +261,12 @@ fn method_with_name(ccx: &CrateContext, impl_id: ast::DefId, name: ast::Name)
meth_did
.def_id
()
}
fn
trans_monomorphized_callee
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
method_call
:
MethodCall
,
trait_id
:
ast
::
DefId
,
n_method
:
uint
,
vtbl
:
typeck
::
vtable_origin
)
->
Callee
<
'a
>
{
fn
trans_monomorphized_callee
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
method_call
:
MethodCall
,
trait_id
:
ast
::
DefId
,
n_method
:
uint
,
vtbl
:
typeck
::
vtable_origin
)
->
Callee
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"meth::trans_monomorphized_callee"
);
match
vtbl
{
typeck
::
vtable_static
(
impl_did
,
rcvr_substs
,
rcvr_origins
)
=>
{
...
...
@@ -324,7 +322,7 @@ fn trans_monomorphized_callee<'a>(
}
}
fn
combine_impl_and_methods_tps
(
bcx
:
&
Block
,
fn
combine_impl_and_methods_tps
(
bcx
:
Block
,
node
:
ExprOrMethodCall
,
rcvr_substs
:
subst
::
Substs
,
rcvr_origins
:
typeck
::
vtable_res
)
...
...
@@ -378,12 +376,12 @@ fn combine_impl_and_methods_tps(bcx: &Block,
(
ty_substs
,
vtables
)
}
fn
trans_trait_callee
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
method_ty
:
ty
::
t
,
n_method
:
uint
,
self_expr
:
&
ast
::
Expr
,
arg_cleanup_scope
:
cleanup
::
ScopeId
)
->
Callee
<
'a
>
{
fn
trans_trait_callee
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
method_ty
:
ty
::
t
,
n_method
:
uint
,
self_expr
:
&
ast
::
Expr
,
arg_cleanup_scope
:
cleanup
::
ScopeId
)
->
Callee
<
'blk
,
'tcx
>
{
/*!
* Create a method callee where the method is coming from a trait
* object (e.g., Box<Trait> type). In this case, we must pull the fn
...
...
@@ -422,11 +420,11 @@ fn trans_trait_callee<'a>(bcx: &'a Block<'a>,
trans_trait_callee_from_llval
(
bcx
,
method_ty
,
n_method
,
llval
)
}
pub
fn
trans_trait_callee_from_llval
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
callee_ty
:
ty
::
t
,
n_method
:
uint
,
llpair
:
ValueRef
)
->
Callee
<
'a
>
{
pub
fn
trans_trait_callee_from_llval
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
callee_ty
:
ty
::
t
,
n_method
:
uint
,
llpair
:
ValueRef
)
->
Callee
<
'blk
,
'tcx
>
{
/*!
* Same as `trans_trait_callee()` above, except that it is given
* a by-ref pointer to the object pair.
...
...
@@ -476,7 +474,7 @@ pub fn trans_trait_callee_from_llval<'a>(bcx: &'a Block<'a>,
/// Creates the self type and (fake) callee substitutions for an unboxed
/// closure with the given def ID. The static region and type parameters are
/// lies, but we're in trans so it doesn't matter.
fn
get_callee_substitutions_for_unboxed_closure
(
bcx
:
&
Block
,
fn
get_callee_substitutions_for_unboxed_closure
(
bcx
:
Block
,
def_id
:
ast
::
DefId
)
->
subst
::
Substs
{
let
self_ty
=
ty
::
mk_unboxed_closure
(
bcx
.tcx
(),
def_id
,
ty
::
ReStatic
);
...
...
@@ -495,7 +493,7 @@ fn get_callee_substitutions_for_unboxed_closure(bcx: &Block,
/// Creates a returns a dynamic vtable for the given type and vtable origin.
/// This is used only for objects.
fn
get_vtable
(
bcx
:
&
Block
,
fn
get_vtable
(
bcx
:
Block
,
self_ty
:
ty
::
t
,
origins
:
typeck
::
vtable_param_res
)
->
ValueRef
...
...
@@ -630,7 +628,7 @@ pub fn make_vtable<I: Iterator<ValueRef>>(ccx: &CrateContext,
}
}
fn
emit_vtable_methods
(
bcx
:
&
Block
,
fn
emit_vtable_methods
(
bcx
:
Block
,
impl_id
:
ast
::
DefId
,
substs
:
subst
::
Substs
,
vtables
:
typeck
::
vtable_res
)
...
...
@@ -686,9 +684,9 @@ fn emit_vtable_methods(bcx: &Block,
})
.collect
()
}
pub
fn
vtable_ptr
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
id
:
ast
::
NodeId
,
self_ty
:
ty
::
t
)
->
ValueRef
{
pub
fn
vtable_ptr
(
bcx
:
Block
,
id
:
ast
::
NodeId
,
self_ty
:
ty
::
t
)
->
ValueRef
{
let
ccx
=
bcx
.ccx
();
let
origins
=
{
let
vtable_map
=
ccx
.tcx
()
.vtable_map
.borrow
();
...
...
@@ -706,11 +704,11 @@ pub fn vtable_ptr<'a>(bcx: &'a Block<'a>,
get_vtable
(
bcx
,
self_ty
,
origins
)
}
pub
fn
trans_trait_cast
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
datum
:
Datum
<
Expr
>
,
id
:
ast
::
NodeId
,
dest
:
expr
::
Dest
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_trait_cast
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
datum
:
Datum
<
Expr
>
,
id
:
ast
::
NodeId
,
dest
:
expr
::
Dest
)
->
Block
<
'blk
,
'tcx
>
{
/*!
* Generates the code to convert from a pointer (`Box<T>`, `&T`, etc)
* into an object (`Box<Trait>`, `&Trait`, etc). This means creating a
...
...
src/librustc/middle/trans/reflect.rs
浏览文件 @
f7a997be
...
...
@@ -33,15 +33,15 @@
use
syntax
::
parse
::
token
::{
InternedString
,
special_idents
};
use
syntax
::
parse
::
token
;
pub
struct
Reflector
<
'a
,
'b
>
{
pub
struct
Reflector
<
'a
,
'b
lk
,
'tcx
:
'blk
>
{
visitor_val
:
ValueRef
,
visitor_items
:
&
'a
[
ty
::
ImplOrTraitItem
],
final_bcx
:
&
'b
Block
<
'b
>
,
final_bcx
:
Block
<
'blk
,
'tcx
>
,
tydesc_ty
:
Type
,
bcx
:
&
'b
Block
<
'b
>
bcx
:
Block
<
'blk
,
'tcx
>
}
impl
<
'a
,
'b
>
Reflector
<
'a
,
'b
>
{
impl
<
'a
,
'b
lk
,
'tcx
>
Reflector
<
'a
,
'blk
,
'tcx
>
{
pub
fn
c_uint
(
&
mut
self
,
u
:
uint
)
->
ValueRef
{
C_uint
(
self
.bcx
.ccx
(),
u
)
}
...
...
@@ -419,12 +419,11 @@ pub fn visit_sig(&mut self, retval: uint, sig: &ty::FnSig) {
}
// Emit a sequence of calls to visit_ty::visit_foo
pub
fn
emit_calls_to_trait_visit_ty
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
t
:
ty
::
t
,
visitor_val
:
ValueRef
,
visitor_trait_id
:
DefId
)
->
&
'a
Block
<
'a
>
{
pub
fn
emit_calls_to_trait_visit_ty
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
t
:
ty
::
t
,
visitor_val
:
ValueRef
,
visitor_trait_id
:
DefId
)
->
Block
<
'blk
,
'tcx
>
{
let
fcx
=
bcx
.fcx
;
let
final
=
fcx
.new_temp_block
(
"final"
);
let
tydesc_ty
=
ty
::
get_tydesc_ty
(
bcx
.tcx
())
.unwrap
();
...
...
src/librustc/middle/trans/tvec.rs
浏览文件 @
f7a997be
...
...
@@ -35,29 +35,28 @@
use
syntax
::
ast
;
use
syntax
::
parse
::
token
::
InternedString
;
fn
get_len
(
bcx
:
&
Block
,
vptr
:
ValueRef
)
->
ValueRef
{
fn
get_len
(
bcx
:
Block
,
vptr
:
ValueRef
)
->
ValueRef
{
let
_
icx
=
push_ctxt
(
"tvec::get_lenl"
);
Load
(
bcx
,
expr
::
get_len
(
bcx
,
vptr
))
}
fn
get_dataptr
(
bcx
:
&
Block
,
vptr
:
ValueRef
)
->
ValueRef
{
fn
get_dataptr
(
bcx
:
Block
,
vptr
:
ValueRef
)
->
ValueRef
{
let
_
icx
=
push_ctxt
(
"tvec::get_dataptr"
);
Load
(
bcx
,
expr
::
get_dataptr
(
bcx
,
vptr
))
}
pub
fn
pointer_add_byte
(
bcx
:
&
Block
,
ptr
:
ValueRef
,
bytes
:
ValueRef
)
->
ValueRef
{
pub
fn
pointer_add_byte
(
bcx
:
Block
,
ptr
:
ValueRef
,
bytes
:
ValueRef
)
->
ValueRef
{
let
_
icx
=
push_ctxt
(
"tvec::pointer_add_byte"
);
let
old_ty
=
val_ty
(
ptr
);
let
bptr
=
PointerCast
(
bcx
,
ptr
,
Type
::
i8p
(
bcx
.ccx
()));
return
PointerCast
(
bcx
,
InBoundsGEP
(
bcx
,
bptr
,
[
bytes
]),
old_ty
);
}
pub
fn
make_drop_glue_unboxed
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
vptr
:
ValueRef
,
unit_ty
:
ty
::
t
,
should_deallocate
:
bool
)
->
&
'a
Block
<
'a
>
{
pub
fn
make_drop_glue_unboxed
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
vptr
:
ValueRef
,
unit_ty
:
ty
::
t
,
should_deallocate
:
bool
)
->
Block
<
'blk
,
'tcx
>
{
let
not_null
=
IsNotNull
(
bcx
,
vptr
);
with_cond
(
bcx
,
not_null
,
|
bcx
|
{
let
ccx
=
bcx
.ccx
();
...
...
@@ -105,11 +104,10 @@ pub fn to_string(&self, ccx: &CrateContext) -> String {
}
}
pub
fn
trans_fixed_vstore
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
expr
:
&
ast
::
Expr
,
dest
:
expr
::
Dest
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_fixed_vstore
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
expr
:
&
ast
::
Expr
,
dest
:
expr
::
Dest
)
->
Block
<
'blk
,
'tcx
>
{
//!
//
// [...] allocates a fixed-size array and moves it around "by value".
...
...
@@ -133,10 +131,10 @@ pub fn trans_fixed_vstore<'a>(
};
}
pub
fn
trans_slice_vec
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
slice_expr
:
&
ast
::
Expr
,
content_expr
:
&
ast
::
Expr
)
->
DatumBlock
<
'a
,
Expr
>
{
pub
fn
trans_slice_vec
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
slice_expr
:
&
ast
::
Expr
,
content_expr
:
&
ast
::
Expr
)
->
DatumBlock
<
'blk
,
'tcx
,
Expr
>
{
/*!
* &[...] allocates memory on the stack and writes the values into it,
* returning the vector (the caller must make the reference). "..." is
...
...
@@ -207,12 +205,11 @@ pub fn trans_slice_vec<'a>(bcx: &'a Block<'a>,
immediate_rvalue_bcx
(
bcx
,
llfixed
,
vec_ty
)
.to_expr_datumblock
()
}
pub
fn
trans_lit_str
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
lit_expr
:
&
ast
::
Expr
,
str_lit
:
InternedString
,
dest
:
Dest
)
->
&
'a
Block
<
'a
>
{
pub
fn
trans_lit_str
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
lit_expr
:
&
ast
::
Expr
,
str_lit
:
InternedString
,
dest
:
Dest
)
->
Block
<
'blk
,
'tcx
>
{
/*!
* Literal strings translate to slices into static memory. This is
* different from trans_slice_vstore() above because it doesn't need to copy
...
...
@@ -239,10 +236,10 @@ pub fn trans_lit_str<'a>(
}
}
pub
fn
trans_uniq_vec
<
'
a
>
(
bcx
:
&
'a
Block
<
'a
>
,
uniq_expr
:
&
ast
::
Expr
,
content_expr
:
&
ast
::
Expr
)
->
DatumBlock
<
'a
,
Expr
>
{
pub
fn
trans_uniq_vec
<
'
blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
uniq_expr
:
&
ast
::
Expr
,
content_expr
:
&
ast
::
Expr
)
->
DatumBlock
<
'blk
,
'tcx
,
Expr
>
{
/*!
* Box<[...]> and "...".to_string() allocate boxes in the exchange heap and write
* the array elements into them.
...
...
@@ -327,13 +324,12 @@ pub fn trans_uniq_vec<'a>(bcx: &'a Block<'a>,
}
}
pub
fn
write_content
<
'a
>
(
bcx
:
&
'a
Block
<
'a
>
,
vt
:
&
VecTypes
,
vstore_expr
:
&
ast
::
Expr
,
content_expr
:
&
ast
::
Expr
,
dest
:
Dest
)
->
&
'a
Block
<
'a
>
{
pub
fn
write_content
<
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
vt
:
&
VecTypes
,
vstore_expr
:
&
ast
::
Expr
,
content_expr
:
&
ast
::
Expr
,
dest
:
Dest
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"tvec::write_content"
);
let
fcx
=
bcx
.fcx
;
let
mut
bcx
=
bcx
;
...
...
@@ -429,12 +425,12 @@ pub fn write_content<'a>(
}
}
pub
fn
vec_types_from_expr
(
bcx
:
&
Block
,
vec_expr
:
&
ast
::
Expr
)
->
VecTypes
{
pub
fn
vec_types_from_expr
(
bcx
:
Block
,
vec_expr
:
&
ast
::
Expr
)
->
VecTypes
{
let
vec_ty
=
node_id_type
(
bcx
,
vec_expr
.id
);
vec_types
(
bcx
,
ty
::
sequence_element_type
(
bcx
.tcx
(),
vec_ty
))
}
pub
fn
vec_types
(
bcx
:
&
Block
,
unit_ty
:
ty
::
t
)
->
VecTypes
{
pub
fn
vec_types
(
bcx
:
Block
,
unit_ty
:
ty
::
t
)
->
VecTypes
{
let
ccx
=
bcx
.ccx
();
let
llunit_ty
=
type_of
::
type_of
(
ccx
,
unit_ty
);
let
llunit_size
=
nonzero_llsize_of
(
ccx
,
llunit_ty
);
...
...
@@ -448,7 +444,7 @@ pub fn vec_types(bcx: &Block, unit_ty: ty::t) -> VecTypes {
}
}
pub
fn
elements_required
(
bcx
:
&
Block
,
content_expr
:
&
ast
::
Expr
)
->
uint
{
pub
fn
elements_required
(
bcx
:
Block
,
content_expr
:
&
ast
::
Expr
)
->
uint
{
//! Figure out the number of elements we need to store this content
match
content_expr
.node
{
...
...
@@ -470,7 +466,7 @@ pub fn elements_required(bcx: &Block, content_expr: &ast::Expr) -> uint {
}
}
pub
fn
get_fixed_base_and_len
(
bcx
:
&
Block
,
pub
fn
get_fixed_base_and_len
(
bcx
:
Block
,
llval
:
ValueRef
,
vec_length
:
uint
)
->
(
ValueRef
,
ValueRef
)
{
...
...
@@ -486,7 +482,7 @@ pub fn get_fixed_base_and_len(bcx: &Block,
(
base
,
len
)
}
fn
get_slice_base_and_len
(
bcx
:
&
Block
,
fn
get_slice_base_and_len
(
bcx
:
Block
,
llval
:
ValueRef
)
->
(
ValueRef
,
ValueRef
)
{
let
base
=
Load
(
bcx
,
GEPi
(
bcx
,
llval
,
[
0u
,
abi
::
slice_elt_base
]));
...
...
@@ -494,7 +490,7 @@ fn get_slice_base_and_len(bcx: &Block,
(
base
,
len
)
}
pub
fn
get_base_and_len
(
bcx
:
&
Block
,
pub
fn
get_base_and_len
(
bcx
:
Block
,
llval
:
ValueRef
,
vec_ty
:
ty
::
t
)
->
(
ValueRef
,
ValueRef
)
{
...
...
@@ -528,17 +524,15 @@ pub fn get_base_and_len(bcx: &Block,
}
}
pub
type
iter_vec_block
<
'r
,
'b
>
=
|
&
'b
Block
<
'b
>
,
ValueRef
,
ty
::
t
|:
'r
->
&
'b
Block
<
'b
>
;
pub
fn
iter_vec_loop
<
'r
,
'b
>
(
bcx
:
&
'b
Block
<
'b
>
,
data_ptr
:
ValueRef
,
vt
:
&
VecTypes
,
count
:
ValueRef
,
f
:
iter_vec_block
<
'r
,
'b
>
)
->
&
'b
Block
<
'b
>
{
pub
type
iter_vec_block
<
'a
,
'blk
,
'tcx
>
=
|
Block
<
'blk
,
'tcx
>
,
ValueRef
,
ty
::
t
|:
'a
->
Block
<
'blk
,
'tcx
>
;
pub
fn
iter_vec_loop
<
'a
,
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
data_ptr
:
ValueRef
,
vt
:
&
VecTypes
,
count
:
ValueRef
,
f
:
iter_vec_block
<
'a
,
'blk
,
'tcx
>
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"tvec::iter_vec_loop"
);
let
fcx
=
bcx
.fcx
;
...
...
@@ -589,14 +583,12 @@ pub fn iter_vec_loop<'r,
next_bcx
}
pub
fn
iter_vec_raw
<
'r
,
'b
>
(
bcx
:
&
'b
Block
<
'b
>
,
data_ptr
:
ValueRef
,
unit_ty
:
ty
::
t
,
len
:
ValueRef
,
f
:
iter_vec_block
<
'r
,
'b
>
)
->
&
'b
Block
<
'b
>
{
pub
fn
iter_vec_raw
<
'a
,
'blk
,
'tcx
>
(
bcx
:
Block
<
'blk
,
'tcx
>
,
data_ptr
:
ValueRef
,
unit_ty
:
ty
::
t
,
len
:
ValueRef
,
f
:
iter_vec_block
<
'a
,
'blk
,
'tcx
>
)
->
Block
<
'blk
,
'tcx
>
{
let
_
icx
=
push_ctxt
(
"tvec::iter_vec_raw"
);
let
fcx
=
bcx
.fcx
;
...
...
src/librustc/middle/trans/value.rs
浏览文件 @
f7a997be
...
...
@@ -55,7 +55,7 @@ pub fn erase_from_parent(self) {
/// This only performs a search for a trivially dominating store. The store
/// must be the only user of this value, and there must not be any conditional
/// branches between the store and the given block.
pub
fn
get_dominating_store
(
self
,
bcx
:
&
Block
)
->
Option
<
Value
>
{
pub
fn
get_dominating_store
(
self
,
bcx
:
Block
)
->
Option
<
Value
>
{
match
self
.get_single_user
()
.and_then
(|
user
|
user
.as_store_inst
())
{
Some
(
store
)
=>
{
store
.get_parent
()
.and_then
(|
store_bb
|
{
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录