Remove inline_asm_call from cg_ssa

`count_insn` is no longer called for inline asm, because it is private to builder.rs

src/librustc_codegen_llvm/asm.rs

@@ -10,7 +10,7 @@ use rustc_codegen_ssa::traits::*;
 use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::mir::operand::OperandValue;
 
-use std::ffi::CString;
+use std::ffi::{CStr, CString};
 use libc::{c_uint, c_char};
 
 
@@ -73,7 +73,8 @@ impl AsmBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
 
         let asm = CString::new(ia.asm.as_str().as_bytes()).unwrap();
         let constraint_cstr = CString::new(all_constraints).unwrap();
-        let r = self.inline_asm_call(
+        let r = inline_asm_call(
+            self,
             &asm,
             &constraint_cstr,
             &inputs,
@@ -119,3 +120,46 @@ impl AsmMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         }
     }
 }
+
+fn inline_asm_call(
+    bx: &mut Builder<'a, 'll, 'tcx>,
+    asm: &CStr,
+    cons: &CStr,
+    inputs: &[&'ll Value],
+    output: &'ll llvm::Type,
+    volatile: bool,
+    alignstack: bool,
+    dia: ::syntax::ast::AsmDialect,
+) -> Option<&'ll Value> {
+    let volatile = if volatile { llvm::True }
+                    else        { llvm::False };
+    let alignstack = if alignstack { llvm::True }
+                        else          { llvm::False };
+
+    let argtys = inputs.iter().map(|v| {
+        debug!("Asm Input Type: {:?}", *v);
+        bx.cx.val_ty(*v)
+    }).collect::<Vec<_>>();
+
+    debug!("Asm Output Type: {:?}", output);
+    let fty = bx.cx.type_func(&argtys[..], output);
+    unsafe {
+        // Ask LLVM to verify that the constraints are well-formed.
+        let constraints_ok = llvm::LLVMRustInlineAsmVerify(fty, cons.as_ptr());
+        debug!("Constraint verification result: {:?}", constraints_ok);
+        if constraints_ok {
+            let v = llvm::LLVMRustInlineAsm(
+                fty,
+                asm.as_ptr(),
+                cons.as_ptr(),
+                volatile,
+                alignstack,
+                llvm::AsmDialect::from_generic(dia),
+            );
+            Some(bx.call(v, inputs, None))
+        } else {
+            // LLVM has detected an issue with our constraints, bail out
+            None
+        }
+    }
+}

src/librustc_codegen_llvm/builder.rs

@@ -1,4 +1,4 @@
-use crate::llvm::{AtomicRmwBinOp, AtomicOrdering, SynchronizationScope, AsmDialect};
+use crate::llvm::{AtomicRmwBinOp, AtomicOrdering, SynchronizationScope};
 use crate::llvm::{self, False, BasicBlock};
 use crate::common::Funclet;
 use crate::context::CodegenCx;
@@ -19,7 +19,6 @@ use rustc_codegen_ssa::base::to_immediate;
 use rustc_codegen_ssa::mir::operand::{OperandValue, OperandRef};
 use rustc_codegen_ssa::mir::place::PlaceRef;
 use std::borrow::Cow;
-use std::ffi::CStr;
 use std::ops::{Deref, Range};
 use std::ptr;
 
@@ -903,45 +902,6 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     }
 
     /* Miscellaneous instructions */
-    fn inline_asm_call(&mut self, asm: &CStr, cons: &CStr,
-                       inputs: &[&'ll Value], output: &'ll Type,
-                       volatile: bool, alignstack: bool,
-                       dia: syntax::ast::AsmDialect) -> Option<&'ll Value> {
-        self.count_insn("inlineasm");
-
-        let volatile = if volatile { llvm::True }
-                       else        { llvm::False };
-        let alignstack = if alignstack { llvm::True }
-                         else          { llvm::False };
-
-        let argtys = inputs.iter().map(|v| {
-            debug!("Asm Input Type: {:?}", *v);
-            self.cx.val_ty(*v)
-        }).collect::<Vec<_>>();
-
-        debug!("Asm Output Type: {:?}", output);
-        let fty = self.type_func(&argtys[..], output);
-        unsafe {
-            // Ask LLVM to verify that the constraints are well-formed.
-            let constraints_ok = llvm::LLVMRustInlineAsmVerify(fty, cons.as_ptr());
-            debug!("Constraint verification result: {:?}", constraints_ok);
-            if constraints_ok {
-                let v = llvm::LLVMRustInlineAsm(
-                    fty,
-                    asm.as_ptr(),
-                    cons.as_ptr(),
-                    volatile,
-                    alignstack,
-                    AsmDialect::from_generic(dia),
-                );
-                Some(self.call(v, inputs, None))
-            } else {
-                // LLVM has detected an issue with our constraints, bail out
-                None
-            }
-        }
-    }
-
     fn memcpy(&mut self, dst: &'ll Value, dst_align: Align,
                   src: &'ll Value, src_align: Align,
                   size: &'ll Value, flags: MemFlags) {

src/librustc_codegen_ssa/traits/builder.rs

@@ -11,10 +11,7 @@ use crate::mir::place::PlaceRef;
 use crate::MemFlags;
 use rustc::ty::Ty;
 use rustc::ty::layout::{Align, Size};
-use std::ffi::CStr;
-
 use std::ops::Range;
-use syntax::ast::AsmDialect;
 
 #[derive(Copy, Clone)]
 pub enum OverflowOp {
@@ -164,17 +161,6 @@ pub trait BuilderMethods<'a, 'tcx: 'a>:
     fn icmp(&mut self, op: IntPredicate, lhs: Self::Value, rhs: Self::Value) -> Self::Value;
     fn fcmp(&mut self, op: RealPredicate, lhs: Self::Value, rhs: Self::Value) -> Self::Value;
 
-    fn inline_asm_call(
-        &mut self,
-        asm: &CStr,
-        cons: &CStr,
-        inputs: &[Self::Value],
-        output: Self::Type,
-        volatile: bool,
-        alignstack: bool,
-        dia: AsmDialect,
-    ) -> Option<Self::Value>;
-
     fn memcpy(
         &mut self,
         dst: Self::Value,