Skip to content

Commit ee982d4

Browse files
arielb1arielb1
committedMay 28, 2017
fix translation of MSVC funclets that loop to their own start
·
1.86.01.19.0
1 parent 6adfbaf commit ee982d4

File tree

5 files changed

+93
-80
lines changed

5 files changed

+93
-80
lines changed
 

‎src/librustc_data_structures/indexed_vec.rs

+7
Original file line numberDiff line numberDiff line change
@@ -212,6 +212,13 @@ impl<I: Idx, T> IndexMut<I> for IndexVec<I, T> {
212212
}
213213
}
214214

215+
impl<I: Idx, T> Default for IndexVec<I, T> {
216+
#[inline]
217+
fn default() -> Self {
218+
Self::new()
219+
}
220+
}
221+
215222
impl<I: Idx, T> Extend<T> for IndexVec<I, T> {
216223
#[inline]
217224
fn extend<J: IntoIterator<Item = T>>(&mut self, iter: J) {

‎src/librustc_trans/common.rs

-9
Original file line numberDiff line numberDiff line change
@@ -191,15 +191,6 @@ impl Funclet {
191191
}
192192
}
193193

194-
impl Clone for Funclet {
195-
fn clone(&self) -> Funclet {
196-
Funclet {
197-
cleanuppad: self.cleanuppad,
198-
operand: OperandBundleDef::new("funclet", &[self.cleanuppad]),
199-
}
200-
}
201-
}
202-
203194
pub fn val_ty(v: ValueRef) -> Type {
204195
unsafe {
205196
Type::from_ref(llvm::LLVMTypeOf(v))

‎src/librustc_trans/mir/analyze.rs

+10
Original file line numberDiff line numberDiff line change
@@ -197,6 +197,16 @@ pub enum CleanupKind {
197197
Internal { funclet: mir::BasicBlock }
198198
}
199199

200+
impl CleanupKind {
201+
pub fn funclet_bb(self, for_bb: mir::BasicBlock) -> Option<mir::BasicBlock> {
202+
match self {
203+
CleanupKind::NotCleanup => None,
204+
CleanupKind::Funclet => Some(for_bb),
205+
CleanupKind::Internal { funclet } => Some(funclet),
206+
}
207+
}
208+
}
209+
200210
pub fn cleanup_kinds<'a, 'tcx>(mir: &mir::Mir<'tcx>) -> IndexVec<mir::BasicBlock, CleanupKind> {
201211
fn discover_masters<'tcx>(result: &mut IndexVec<mir::BasicBlock, CleanupKind>,
202212
mir: &mir::Mir<'tcx>) {

‎src/librustc_trans/mir/block.rs

+44-53
Original file line numberDiff line numberDiff line change
@@ -19,104 +19,96 @@ use adt;
1919
use base::{self, Lifetime};
2020
use callee;
2121
use builder::Builder;
22-
use common::{self, Funclet};
23-
use common::{C_bool, C_str_slice, C_struct, C_u32, C_undef};
22+
use common::{self, C_bool, C_str_slice, C_struct, C_u32, C_undef};
2423
use consts;
2524
use machine::llalign_of_min;
2625
use meth;
2726
use monomorphize;
2827
use type_of;
2928
use type_::Type;
3029

31-
use rustc_data_structures::indexed_vec::IndexVec;
3230
use syntax::symbol::Symbol;
3331

3432
use std::cmp;
3533

3634
use super::{MirContext, LocalRef};
37-
use super::analyze::CleanupKind;
3835
use super::constant::Const;
3936
use super::lvalue::{Alignment, LvalueRef};
4037
use super::operand::OperandRef;
4138
use super::operand::OperandValue::{Pair, Ref, Immediate};
4239

4340
impl<'a, 'tcx> MirContext<'a, 'tcx> {
44-
pub fn trans_block(&mut self, bb: mir::BasicBlock,
45-
funclets: &IndexVec<mir::BasicBlock, Option<Funclet>>) {
41+
pub fn trans_block(&mut self, bb: mir::BasicBlock) {
4642
let mut bcx = self.get_builder(bb);
4743
let data = &self.mir[bb];
4844

4945
debug!("trans_block({:?}={:?})", bb, data);
5046

51-
let funclet = match self.cleanup_kinds[bb] {
52-
CleanupKind::Internal { funclet } => funclets[funclet].as_ref(),
53-
_ => funclets[bb].as_ref(),
54-
};
55-
5647
for statement in &data.statements {
5748
bcx = self.trans_statement(bcx, statement);
5849
}
5950

60-
self.trans_terminator(bcx, bb, data.terminator(), funclet);
51+
self.trans_terminator(bcx, bb, data.terminator());
6152
}
6253

6354
fn trans_terminator(&mut self,
6455
mut bcx: Builder<'a, 'tcx>,
6556
bb: mir::BasicBlock,
66-
terminator: &mir::Terminator<'tcx>,
67-
funclet: Option<&Funclet>)
57+
terminator: &mir::Terminator<'tcx>)
6858
{
6959
debug!("trans_terminator: {:?}", terminator);
7060

7161
// Create the cleanup bundle, if needed.
7262
let tcx = bcx.tcx();
63+
let span = terminator.source_info.span;
64+
let funclet_bb = self.cleanup_kinds[bb].funclet_bb(bb);
65+
let funclet = funclet_bb.and_then(|funclet_bb| self.funclets[funclet_bb].as_ref());
66+
7367
let cleanup_pad = funclet.map(|lp| lp.cleanuppad());
7468
let cleanup_bundle = funclet.map(|l| l.bundle());
7569

76-
let funclet_br = |this: &Self, bcx: Builder, bb: mir::BasicBlock| {
77-
let lltarget = this.blocks[bb];
78-
if let Some(cp) = cleanup_pad {
79-
match this.cleanup_kinds[bb] {
80-
CleanupKind::Funclet => {
81-
// micro-optimization: generate a `ret` rather than a jump
82-
// to a return block
83-
bcx.cleanup_ret(cp, Some(lltarget));
84-
}
85-
CleanupKind::Internal { .. } => bcx.br(lltarget),
86-
CleanupKind::NotCleanup => bug!("jump from cleanup bb to bb {:?}", bb)
70+
let lltarget = |this: &mut Self, target: mir::BasicBlock| {
71+
let lltarget = this.blocks[target];
72+
let target_funclet = this.cleanup_kinds[target].funclet_bb(target);
73+
match (funclet_bb, target_funclet) {
74+
(None, None) => (lltarget, false),
75+
(Some(f), Some(t_f))
76+
if f == t_f || !base::wants_msvc_seh(tcx.sess)
77+
=> (lltarget, false),
78+
(None, Some(_)) => {
79+
// jump *into* cleanup - need a landing pad if GNU
80+
(this.landing_pad_to(target), false)
81+
}
82+
(Some(_), None) => span_bug!(span, "{:?} - jump out of cleanup?", terminator),
83+
(Some(_), Some(_)) => {
84+
(this.landing_pad_to(target), true)
8785
}
88-
} else {
89-
bcx.br(lltarget);
9086
}
9187
};
9288

9389
let llblock = |this: &mut Self, target: mir::BasicBlock| {
94-
let lltarget = this.blocks[target];
95-
96-
if let Some(cp) = cleanup_pad {
97-
match this.cleanup_kinds[target] {
98-
CleanupKind::Funclet => {
99-
// MSVC cross-funclet jump - need a trampoline
90+
let (lltarget, is_cleanupret) = lltarget(this, target);
91+
if is_cleanupret {
92+
// MSVC cross-funclet jump - need a trampoline
93+
94+
debug!("llblock: creating cleanup trampoline for {:?}", target);
95+
let name = &format!("{:?}_cleanup_trampoline_{:?}", bb, target);
96+
let trampoline = this.new_block(name);
97+
trampoline.cleanup_ret(cleanup_pad.unwrap(), Some(lltarget));
98+
trampoline.llbb()
99+
} else {
100+
lltarget
101+
}
102+
};
100103

101-
debug!("llblock: creating cleanup trampoline for {:?}", target);
102-
let name = &format!("{:?}_cleanup_trampoline_{:?}", bb, target);
103-
let trampoline = this.new_block(name);
104-
trampoline.cleanup_ret(cp, Some(lltarget));
105-
trampoline.llbb()
106-
}
107-
CleanupKind::Internal { .. } => lltarget,
108-
CleanupKind::NotCleanup =>
109-
bug!("jump from cleanup bb {:?} to bb {:?}", bb, target)
110-
}
104+
let funclet_br = |this: &mut Self, bcx: Builder, target: mir::BasicBlock| {
105+
let (lltarget, is_cleanupret) = lltarget(this, target);
106+
if is_cleanupret {
107+
// micro-optimization: generate a `ret` rather than a jump
108+
// to a trampoline.
109+
bcx.cleanup_ret(cleanup_pad.unwrap(), Some(lltarget));
111110
} else {
112-
if let (CleanupKind::NotCleanup, CleanupKind::Funclet) =
113-
(this.cleanup_kinds[bb], this.cleanup_kinds[target])
114-
{
115-
// jump *into* cleanup - need a landing pad if GNU
116-
this.landing_pad_to(target)
117-
} else {
118-
lltarget
119-
}
111+
bcx.br(lltarget);
120112
}
121113
};
122114

@@ -168,7 +160,6 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
168160
}
169161
};
170162

171-
let span = terminator.source_info.span;
172163
self.set_debug_loc(&bcx, terminator.source_info);
173164
match terminator.kind {
174165
mir::TerminatorKind::Resume => {
@@ -752,7 +743,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
752743

753744
fn landing_pad_uncached(&mut self, target_bb: BasicBlockRef) -> BasicBlockRef {
754745
if base::wants_msvc_seh(self.ccx.sess()) {
755-
return target_bb;
746+
span_bug!(self.mir.span, "landing pad was not inserted?")
756747
}
757748

758749
let bcx = self.new_block("cleanup");

‎src/librustc_trans/mir/mod.rs

+32-18
Original file line numberDiff line numberDiff line change
@@ -69,6 +69,10 @@ pub struct MirContext<'a, 'tcx:'a> {
6969
/// The funclet status of each basic block
7070
cleanup_kinds: IndexVec<mir::BasicBlock, analyze::CleanupKind>,
7171

72+
/// When targeting MSVC, this stores the cleanup info for each funclet
73+
/// BB. This is initialized as we compute the funclets' head block in RPO.
74+
funclets: &'a IndexVec<mir::BasicBlock, Option<Funclet>>,
75+
7276
/// This stores the landing-pad block for a given BB, computed lazily on GNU
7377
/// and eagerly on MSVC.
7478
landing_pads: IndexVec<mir::BasicBlock, Option<BasicBlockRef>>,
@@ -202,8 +206,11 @@ pub fn trans_mir<'a, 'tcx: 'a>(
202206
debuginfo::create_function_debug_context(ccx, instance, sig, llfn, mir);
203207
let bcx = Builder::new_block(ccx, llfn, "start");
204208

205-
let cleanup_kinds = analyze::cleanup_kinds(&mir);
209+
if mir.basic_blocks().iter().any(|bb| bb.is_cleanup) {
210+
bcx.set_personality_fn(ccx.eh_personality());
211+
}
206212

213+
let cleanup_kinds = analyze::cleanup_kinds(&mir);
207214
// Allocate a `Block` for every basic block, except
208215
// the start block, if nothing loops back to it.
209216
let reentrant_start_block = !mir.predecessors_for(mir::START_BLOCK).is_empty();
@@ -218,6 +225,7 @@ pub fn trans_mir<'a, 'tcx: 'a>(
218225

219226
// Compute debuginfo scopes from MIR scopes.
220227
let scopes = debuginfo::create_mir_scopes(ccx, mir, &debug_context);
228+
let (landing_pads, funclets) = create_funclets(&bcx, &cleanup_kinds, &block_bcxs);
221229

222230
let mut mircx = MirContext {
223231
mir: mir,
@@ -228,7 +236,8 @@ pub fn trans_mir<'a, 'tcx: 'a>(
228236
blocks: block_bcxs,
229237
unreachable_block: None,
230238
cleanup_kinds: cleanup_kinds,
231-
landing_pads: IndexVec::from_elem(None, mir.basic_blocks()),
239+
landing_pads: landing_pads,
240+
funclets: &funclets,
232241
scopes: scopes,
233242
locals: IndexVec::new(),
234243
debug_context: debug_context,
@@ -306,28 +315,13 @@ pub fn trans_mir<'a, 'tcx: 'a>(
306315
// emitting should be enabled.
307316
debuginfo::start_emitting_source_locations(&mircx.debug_context);
308317

309-
let funclets: IndexVec<mir::BasicBlock, Option<Funclet>> =
310-
mircx.cleanup_kinds.iter_enumerated().map(|(bb, cleanup_kind)| {
311-
if let CleanupKind::Funclet = *cleanup_kind {
312-
let bcx = mircx.get_builder(bb);
313-
unsafe {
314-
llvm::LLVMSetPersonalityFn(mircx.llfn, mircx.ccx.eh_personality());
315-
}
316-
if base::wants_msvc_seh(ccx.sess()) {
317-
return Some(Funclet::new(bcx.cleanup_pad(None, &[])));
318-
}
319-
}
320-
321-
None
322-
}).collect();
323-
324318
let rpo = traversal::reverse_postorder(&mir);
325319
let mut visited = BitVector::new(mir.basic_blocks().len());
326320

327321
// Translate the body of each block using reverse postorder
328322
for (bb, _) in rpo {
329323
visited.insert(bb.index());
330-
mircx.trans_block(bb, &funclets);
324+
mircx.trans_block(bb);
331325
}
332326

333327
// Remove blocks that haven't been visited, or have no
@@ -343,6 +337,26 @@ pub fn trans_mir<'a, 'tcx: 'a>(
343337
}
344338
}
345339

340+
fn create_funclets<'a, 'tcx>(
341+
bcx: &Builder<'a, 'tcx>,
342+
cleanup_kinds: &IndexVec<mir::BasicBlock, CleanupKind>,
343+
block_bcxs: &IndexVec<mir::BasicBlock, BasicBlockRef>)
344+
-> (IndexVec<mir::BasicBlock, Option<BasicBlockRef>>,
345+
IndexVec<mir::BasicBlock, Option<Funclet>>)
346+
{
347+
block_bcxs.iter_enumerated().zip(cleanup_kinds).map(|((bb, &llbb), cleanup_kind)| {
348+
match *cleanup_kind {
349+
CleanupKind::Funclet if base::wants_msvc_seh(bcx.sess()) => {
350+
let cleanup_bcx = bcx.build_sibling_block(&format!("funclet_{:?}", bb));
351+
let cleanup = cleanup_bcx.cleanup_pad(None, &[]);
352+
cleanup_bcx.br(llbb);
353+
(Some(cleanup_bcx.llbb()), Some(Funclet::new(cleanup)))
354+
}
355+
_ => (None, None)
356+
}
357+
}).unzip()
358+
}
359+
346360
/// Produce, for each argument, a `ValueRef` pointing at the
347361
/// argument's value. As arguments are lvalues, these are always
348362
/// indirect.

0 commit comments

Comments
 (0)
Please sign in to comment.