Move unwinding related methods to UnwindBuilderMethods

Author: bjorn3

src/librustc_codegen_llvm/builder.rs

@@ -898,6 +898,128 @@ impl NumBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
     }
 }
 
+impl UnwindBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
+    fn invoke(
+        &mut self,
+        llfn: &'ll Value,
+        args: &[&'ll Value],
+        then: &'ll BasicBlock,
+        catch: &'ll BasicBlock,
+        funclet: Option<&Funclet<'ll>>,
+    ) -> &'ll Value {
+        self.count_insn("invoke");
+
+        debug!("Invoke {:?} with args ({:?})",
+               llfn,
+               args);
+
+        let args = self.check_call("invoke", llfn, args);
+        let bundle = funclet.map(|funclet| funclet.bundle());
+        let bundle = bundle.as_ref().map(|b| &*b.raw);
+
+        unsafe {
+            llvm::LLVMRustBuildInvoke(self.llbuilder,
+                                      llfn,
+                                      args.as_ptr(),
+                                      args.len() as c_uint,
+                                      then,
+                                      catch,
+                                      bundle,
+                                      noname())
+        }
+    }
+
+    fn landing_pad(&mut self, ty: &'ll Type, pers_fn: &'ll Value,
+                       num_clauses: usize) -> &'ll Value {
+        self.count_insn("landingpad");
+        unsafe {
+            llvm::LLVMBuildLandingPad(self.llbuilder, ty, pers_fn,
+                                      num_clauses as c_uint, noname())
+        }
+    }
+
+    fn set_cleanup(&mut self, landing_pad: &'ll Value) {
+        self.count_insn("setcleanup");
+        unsafe {
+            llvm::LLVMSetCleanup(landing_pad, llvm::True);
+        }
+    }
+
+    fn resume(&mut self, exn: &'ll Value) -> &'ll Value {
+        self.count_insn("resume");
+        unsafe {
+            llvm::LLVMBuildResume(self.llbuilder, exn)
+        }
+    }
+
+    fn cleanup_pad(&mut self,
+                       parent: Option<&'ll Value>,
+                       args: &[&'ll Value]) -> Funclet<'ll> {
+        self.count_insn("cleanuppad");
+        let name = const_cstr!("cleanuppad");
+        let ret = unsafe {
+            llvm::LLVMRustBuildCleanupPad(self.llbuilder,
+                                          parent,
+                                          args.len() as c_uint,
+                                          args.as_ptr(),
+                                          name.as_ptr())
+        };
+        Funclet::new(ret.expect("LLVM does not have support for cleanuppad"))
+    }
+
+    fn cleanup_ret(
+        &mut self, funclet: &Funclet<'ll>,
+        unwind: Option<&'ll BasicBlock>,
+    ) -> &'ll Value {
+        self.count_insn("cleanupret");
+        let ret = unsafe {
+            llvm::LLVMRustBuildCleanupRet(self.llbuilder, funclet.cleanuppad(), unwind)
+        };
+        ret.expect("LLVM does not have support for cleanupret")
+    }
+
+    fn catch_pad(&mut self,
+                     parent: &'ll Value,
+                     args: &[&'ll Value]) -> Funclet<'ll> {
+        self.count_insn("catchpad");
+        let name = const_cstr!("catchpad");
+        let ret = unsafe {
+            llvm::LLVMRustBuildCatchPad(self.llbuilder, parent,
+                                        args.len() as c_uint, args.as_ptr(),
+                                        name.as_ptr())
+        };
+        Funclet::new(ret.expect("LLVM does not have support for catchpad"))
+    }
+
+    fn catch_switch(
+        &mut self,
+        parent: Option<&'ll Value>,
+        unwind: Option<&'ll BasicBlock>,
+        num_handlers: usize,
+    ) -> &'ll Value {
+        self.count_insn("catchswitch");
+        let name = const_cstr!("catchswitch");
+        let ret = unsafe {
+            llvm::LLVMRustBuildCatchSwitch(self.llbuilder, parent, unwind,
+                                           num_handlers 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);
+        }
+    }
+
+    fn set_personality_fn(&mut self, personality: &'ll Value) {
+        unsafe {
+            llvm::LLVMSetPersonalityFn(self.llfn(), personality);
+        }
+    }
+}
+
 impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     fn new_block<'b>(
         cx: &'a CodegenCx<'ll, 'tcx>,
@@ -988,36 +1110,6 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         }
     }
 
-    fn invoke(
-        &mut self,
-        llfn: &'ll Value,
-        args: &[&'ll Value],
-        then: &'ll BasicBlock,
-        catch: &'ll BasicBlock,
-        funclet: Option<&Funclet<'ll>>,
-    ) -> &'ll Value {
-        self.count_insn("invoke");
-
-        debug!("Invoke {:?} with args ({:?})",
-               llfn,
-               args);
-
-        let args = self.check_call("invoke", llfn, args);
-        let bundle = funclet.map(|funclet| funclet.bundle());
-        let bundle = bundle.as_ref().map(|b| &*b.raw);
-
-        unsafe {
-            llvm::LLVMRustBuildInvoke(self.llbuilder,
-                                      llfn,
-                                      args.as_ptr(),
-                                      args.len() as c_uint,
-                                      then,
-                                      catch,
-                                      bundle,
-                                      noname())
-        }
-    }
-
     fn unreachable(&mut self) {
         self.count_insn("unreachable");
         unsafe {
@@ -1119,96 +1211,6 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         }
     }
 
-    fn landing_pad(&mut self, ty: &'ll Type, pers_fn: &'ll Value,
-                       num_clauses: usize) -> &'ll Value {
-        self.count_insn("landingpad");
-        unsafe {
-            llvm::LLVMBuildLandingPad(self.llbuilder, ty, pers_fn,
-                                      num_clauses as c_uint, noname())
-        }
-    }
-
-    fn set_cleanup(&mut self, landing_pad: &'ll Value) {
-        self.count_insn("setcleanup");
-        unsafe {
-            llvm::LLVMSetCleanup(landing_pad, llvm::True);
-        }
-    }
-
-    fn resume(&mut self, exn: &'ll Value) -> &'ll Value {
-        self.count_insn("resume");
-        unsafe {
-            llvm::LLVMBuildResume(self.llbuilder, exn)
-        }
-    }
-
-    fn cleanup_pad(&mut self,
-                       parent: Option<&'ll Value>,
-                       args: &[&'ll Value]) -> Funclet<'ll> {
-        self.count_insn("cleanuppad");
-        let name = const_cstr!("cleanuppad");
-        let ret = unsafe {
-            llvm::LLVMRustBuildCleanupPad(self.llbuilder,
-                                          parent,
-                                          args.len() as c_uint,
-                                          args.as_ptr(),
-                                          name.as_ptr())
-        };
-        Funclet::new(ret.expect("LLVM does not have support for cleanuppad"))
-    }
-
-    fn cleanup_ret(
-        &mut self, funclet: &Funclet<'ll>,
-        unwind: Option<&'ll BasicBlock>,
-    ) -> &'ll Value {
-        self.count_insn("cleanupret");
-        let ret = unsafe {
-            llvm::LLVMRustBuildCleanupRet(self.llbuilder, funclet.cleanuppad(), unwind)
-        };
-        ret.expect("LLVM does not have support for cleanupret")
-    }
-
-    fn catch_pad(&mut self,
-                     parent: &'ll Value,
-                     args: &[&'ll Value]) -> Funclet<'ll> {
-        self.count_insn("catchpad");
-        let name = const_cstr!("catchpad");
-        let ret = unsafe {
-            llvm::LLVMRustBuildCatchPad(self.llbuilder, parent,
-                                        args.len() as c_uint, args.as_ptr(),
-                                        name.as_ptr())
-        };
-        Funclet::new(ret.expect("LLVM does not have support for catchpad"))
-    }
-
-    fn catch_switch(
-        &mut self,
-        parent: Option<&'ll Value>,
-        unwind: Option<&'ll BasicBlock>,
-        num_handlers: usize,
-    ) -> &'ll Value {
-        self.count_insn("catchswitch");
-        let name = const_cstr!("catchswitch");
-        let ret = unsafe {
-            llvm::LLVMRustBuildCatchSwitch(self.llbuilder, parent, unwind,
-                                           num_handlers 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);
-        }
-    }
-
-    fn set_personality_fn(&mut self, personality: &'ll Value) {
-        unsafe {
-            llvm::LLVMSetPersonalityFn(self.llfn(), personality);
-        }
-    }
-
     fn add_case(&mut self, s: &'ll Value, on_val: &'ll Value, dest: &'ll BasicBlock) {
         unsafe {
             llvm::LLVMAddCase(s, on_val, dest)

src/librustc_codegen_ssa/traits/builder.rs

@@ -184,6 +184,40 @@ pub trait NumBuilderMethods<'tcx>: HasCodegen<'tcx> {
     fn fcmp(&mut self, op: RealPredicate, lhs: Self::Value, rhs: Self::Value) -> Self::Value;
 }
 
+pub trait UnwindBuilderMethods<'tcx>: HasCodegen<'tcx> {
+    fn invoke(
+        &mut self,
+        llfn: Self::Value,
+        args: &[Self::Value],
+        then: Self::BasicBlock,
+        catch: Self::BasicBlock,
+        funclet: Option<&Self::Funclet>,
+    ) -> Self::Value;
+    fn landing_pad(
+        &mut self,
+        ty: Self::Type,
+        pers_fn: Self::Value,
+        num_clauses: usize,
+    ) -> Self::Value;
+    fn set_cleanup(&mut self, landing_pad: Self::Value);
+    fn resume(&mut self, exn: Self::Value) -> Self::Value;
+    fn cleanup_pad(&mut self, parent: Option<Self::Value>, args: &[Self::Value]) -> Self::Funclet;
+    fn cleanup_ret(
+        &mut self,
+        funclet: &Self::Funclet,
+        unwind: Option<Self::BasicBlock>,
+    ) -> Self::Value;
+    fn catch_pad(&mut self, parent: Self::Value, args: &[Self::Value]) -> Self::Funclet;
+    fn catch_switch(
+        &mut self,
+        parent: Option<Self::Value>,
+        unwind: Option<Self::BasicBlock>,
+        num_handlers: usize,
+    ) -> Self::Value;
+    fn add_handler(&mut self, catch_switch: Self::Value, handler: Self::BasicBlock);
+    fn set_personality_fn(&mut self, personality: Self::Value);
+}
+
 pub trait BuilderMethods<'a, 'tcx: 'a>:
     HasCodegen<'tcx>
     + DebugInfoBuilderMethods<'tcx>
@@ -194,6 +228,7 @@ pub trait BuilderMethods<'a, 'tcx: 'a>:
     + StaticBuilderMethods<'tcx>
     + MemoryBuilderMethods<'tcx>
     + NumBuilderMethods<'tcx>
+    + UnwindBuilderMethods<'tcx>
 {
     fn new_block<'b>(cx: &'a Self::CodegenCx, llfn: Self::Value, name: &'b str) -> Self;
     fn with_cx(cx: &'a Self::CodegenCx) -> Self;
@@ -216,14 +251,6 @@ pub trait BuilderMethods<'a, 'tcx: 'a>:
         else_llbb: Self::BasicBlock,
         num_cases: usize,
     ) -> Self::Value;
-    fn invoke(
-        &mut self,
-        llfn: Self::Value,
-        args: &[Self::Value],
-        then: Self::BasicBlock,
-        catch: Self::BasicBlock,
-        funclet: Option<&Self::Funclet>,
-    ) -> Self::Value;
     fn unreachable(&mut self);
 
     fn inline_asm_call(
@@ -250,30 +277,6 @@ pub trait BuilderMethods<'a, 'tcx: 'a>:
     fn extract_value(&mut self, agg_val: Self::Value, idx: u64) -> Self::Value;
     fn insert_value(&mut self, agg_val: Self::Value, elt: Self::Value, idx: u64) -> Self::Value;
 
-    fn landing_pad(
-        &mut self,
-        ty: Self::Type,
-        pers_fn: Self::Value,
-        num_clauses: usize,
-    ) -> Self::Value;
-    fn set_cleanup(&mut self, landing_pad: Self::Value);
-    fn resume(&mut self, exn: Self::Value) -> Self::Value;
-    fn cleanup_pad(&mut self, parent: Option<Self::Value>, args: &[Self::Value]) -> Self::Funclet;
-    fn cleanup_ret(
-        &mut self,
-        funclet: &Self::Funclet,
-        unwind: Option<Self::BasicBlock>,
-    ) -> Self::Value;
-    fn catch_pad(&mut self, parent: Self::Value, args: &[Self::Value]) -> Self::Funclet;
-    fn catch_switch(
-        &mut self,
-        parent: Option<Self::Value>,
-        unwind: Option<Self::BasicBlock>,
-        num_handlers: usize,
-    ) -> Self::Value;
-    fn add_handler(&mut self, catch_switch: Self::Value, handler: Self::BasicBlock);
-    fn set_personality_fn(&mut self, personality: Self::Value);
-
     fn add_case(&mut self, s: Self::Value, on_val: Self::Value, dest: Self::BasicBlock);
     fn set_invariant_load(&mut self, load: Self::Value);