rustc_codegen_ssa: turn builders "unpositioned" after emitting a terminator.

compiler/rustc_codegen_llvm/src/builder.rs

@@ -117,21 +117,36 @@ macro_rules! builder_methods_for_value_instructions {
     }
 }
 
+// HACK(eddyb) this is an easy way to avoid a complex relationship between
+// `Builder` and `UnpositionedBuilder`, even if it seems lopsided.
+pub struct UnpositionedBuilder<'a, 'll, 'tcx>(Builder<'a, 'll, 'tcx>);
+
 impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
+    type Unpositioned = UnpositionedBuilder<'a, 'll, 'tcx>;
+
+    fn unpositioned(cx: &'a CodegenCx<'ll, 'tcx>) -> Self::Unpositioned {
+        // Create a fresh builder from the crate context.
+        let llbuilder = unsafe { llvm::LLVMCreateBuilderInContext(cx.llcx) };
+        UnpositionedBuilder(Builder { llbuilder, cx })
+    }
+
+    fn position_at_end(bx: Self::Unpositioned, llbb: &'ll BasicBlock) -> Self {
+        unsafe {
+            llvm::LLVMPositionBuilderAtEnd(bx.0.llbuilder, llbb);
+        }
+        bx.0
+    }
+
+    fn into_unpositioned(self) -> Self::Unpositioned {
+        UnpositionedBuilder(self)
+    }
+
     fn new_block<'b>(cx: &'a CodegenCx<'ll, 'tcx>, llfn: &'ll Value, name: &'b str) -> Self {
-        let mut bx = Builder::with_cx(cx);
         let llbb = unsafe {
             let name = SmallCStr::new(name);
             llvm::LLVMAppendBasicBlockInContext(cx.llcx, llfn, name.as_ptr())
         };
-        bx.position_at_end(llbb);
-        bx
-    }
-
-    fn with_cx(cx: &'a CodegenCx<'ll, 'tcx>) -> Self {
-        // Create a fresh builder from the crate context.
-        let llbuilder = unsafe { llvm::LLVMCreateBuilderInContext(cx.llcx) };
-        Builder { llbuilder, cx }
+        Self::position_at_end(Self::unpositioned(cx), llbb)
     }
 
     fn build_sibling_block(&self, name: &str) -> Self {
@@ -144,12 +159,6 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
 
     fn set_span(&mut self, _span: Span) {}
 
-    fn position_at_end(&mut self, llbb: &'ll BasicBlock) {
-        unsafe {
-            llvm::LLVMPositionBuilderAtEnd(self.llbuilder, llbb);
-        }
-    }
-
     fn ret_void(&mut self) {
         unsafe {
             llvm::LLVMBuildRetVoid(self.llbuilder);
@@ -384,9 +393,8 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     }
 
     fn alloca(&mut self, ty: &'ll Type, align: Align) -> &'ll Value {
-        let mut bx = Builder::with_cx(self.cx);
-        bx.position_at_start(unsafe { llvm::LLVMGetFirstBasicBlock(self.llfn()) });
-        bx.dynamic_alloca(ty, align)
+        let entry_llbb = unsafe { llvm::LLVMGetFirstBasicBlock(self.llfn()) };
+        Self::position_at_start(Self::unpositioned(self.cx), entry_llbb).dynamic_alloca(ty, align)
     }
 
     fn dynamic_alloca(&mut self, ty: &'ll Type, align: Align) -> &'ll Value {
@@ -989,25 +997,25 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         &mut self,
         parent: Option<&'ll Value>,
         unwind: Option<&'ll BasicBlock>,
-        num_handlers: usize,
+        handlers: &[&'ll BasicBlock],
     ) -> &'ll Value {
         let name = cstr!("catchswitch");
         let ret = unsafe {
             llvm::LLVMRustBuildCatchSwitch(
                 self.llbuilder,
                 parent,
                 unwind,
-                num_handlers as c_uint,
+                handlers.len() as c_uint,
                 name.as_ptr(),
             )
         };
-        ret.expect("LLVM does not have support for catchswitch")
-    }
-
-    fn add_handler(&mut self, catch_switch: &'ll Value, handler: &'ll BasicBlock) {
-        unsafe {
-            llvm::LLVMRustAddHandler(catch_switch, handler);
+        let catch_switch = ret.expect("LLVM does not have support for catchswitch");
+        for &handler in handlers {
+            unsafe {
+                llvm::LLVMRustAddHandler(catch_switch, handler);
+            }
         }
+        catch_switch
     }
 
     fn set_personality_fn(&mut self, personality: &'ll Value) {
@@ -1169,10 +1177,11 @@ impl Builder<'a, 'll, 'tcx> {
         unsafe { llvm::LLVMGetBasicBlockParent(self.llbb()) }
     }
 
-    fn position_at_start(&mut self, llbb: &'ll BasicBlock) {
+    fn position_at_start(bx: UnpositionedBuilder<'a, 'll, 'tcx>, llbb: &'ll BasicBlock) -> Self {
         unsafe {
-            llvm::LLVMRustPositionBuilderAtStart(self.llbuilder, llbb);
+            llvm::LLVMRustPositionBuilderAtStart(bx.0.llbuilder, llbb);
         }
+        bx.0
     }
 
     pub fn minnum(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -465,9 +465,8 @@ fn codegen_msvc_try(
 
         normal.ret(bx.const_i32(0));
 
-        let cs = catchswitch.catch_switch(None, None, 2);
-        catchswitch.add_handler(cs, catchpad_rust.llbb());
-        catchswitch.add_handler(cs, catchpad_foreign.llbb());
+        let cs =
+            catchswitch.catch_switch(None, None, &[catchpad_rust.llbb(), catchpad_foreign.llbb()]);
 
         // We can't use the TypeDescriptor defined in libpanic_unwind because it
         // might be in another DLL and the SEH encoding only supports specifying

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -1245,9 +1245,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     }
 
     pub fn build_block(&self, bb: mir::BasicBlock) -> Bx {
-        let mut bx = Bx::with_cx(self.cx);
-        bx.position_at_end(self.blocks[bb]);
-        bx
+        Bx::position_at_end(Bx::unpositioned(self.cx), self.blocks[bb])
     }
 
     fn make_return_dest(

compiler/rustc_codegen_ssa/src/mir/mod.rs

@@ -317,8 +317,7 @@ fn create_funclets<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
                     let mut cp_bx = bx.build_sibling_block(&format!("cp_funclet{:?}", bb));
                     ret_llbb = cs_bx.llbb();
 
-                    let cs = cs_bx.catch_switch(None, None, 1);
-                    cs_bx.add_handler(cs, cp_bx.llbb());
+                    let cs = cs_bx.catch_switch(None, None, &[cp_bx.llbb()]);
 
                     // The "null" here is actually a RTTI type descriptor for the
                     // C++ personality function, but `catch (...)` has no type so

compiler/rustc_codegen_ssa/src/traits/builder.rs

@@ -40,14 +40,22 @@ pub trait BuilderMethods<'a, 'tcx>:
     + HasParamEnv<'tcx>
     + HasTargetSpec
 {
+    /// IR builder (like `Self`) that doesn't have a set (insert) position, and
+    /// cannot be used until positioned (which converted it to `Self`).
+    // FIXME(eddyb) maybe move this associated type to a different trait, and/or
+    // provide an `UnpositionedBuilderMethods` trait for operations involving it.
+    type Unpositioned;
+
+    fn unpositioned(cx: &'a Self::CodegenCx) -> Self::Unpositioned;
+    fn position_at_end(bx: Self::Unpositioned, llbb: Self::BasicBlock) -> Self;
+    fn into_unpositioned(self) -> Self::Unpositioned;
+
     fn new_block<'b>(cx: &'a Self::CodegenCx, llfn: Self::Function, name: &'b str) -> Self;
-    fn with_cx(cx: &'a Self::CodegenCx) -> Self;
     fn build_sibling_block(&self, name: &str) -> Self;
     fn cx(&self) -> &Self::CodegenCx;
     fn llbb(&self) -> Self::BasicBlock;
     fn set_span(&mut self, span: Span);
 
-    fn position_at_end(&mut self, llbb: Self::BasicBlock);
     fn ret_void(&mut self);
     fn ret(&mut self, v: Self::Value);
     fn br(&mut self, dest: Self::BasicBlock);
@@ -245,9 +253,8 @@ pub trait BuilderMethods<'a, 'tcx>:
         &mut self,
         parent: Option<Self::Value>,
         unwind: Option<Self::BasicBlock>,
-        num_handlers: usize,
+        handlers: &[Self::BasicBlock],
     ) -> Self::Value;
-    fn add_handler(&mut self, catch_switch: Self::Value, handler: Self::BasicBlock);
     fn set_personality_fn(&mut self, personality: Self::Value);
 
     fn atomic_cmpxchg(