Move doc to trait declarations

Author: denismerigoux

src/librustc_codegen_llvm/asm.rs

@@ -25,7 +25,6 @@ use libc::{c_uint, c_char};
 
 
 impl AsmBuilderMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx, &'ll Value> {
- // Take an inline assembly expression and splat it out via LLVM
  fn codegen_inline_asm(
  &self,
  ia: &hir::InlineAsm,

src/librustc_codegen_llvm/base.rs

@@ -158,14 +158,14 @@ pub fn bin_op_to_fcmp_predicate(op: hir::BinOpKind) -> RealPredicate {
  }
 }
 
-pub fn compare_simd_types<'a, 'll:'a, 'tcx:'ll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
- bx: &Builder,
- lhs: <Builder::CodegenCx as Backend<'ll>>::Value,
- rhs: <Builder::CodegenCx as Backend<'ll>>::Value,
+pub fn compare_simd_types<'a, 'll:'a, 'tcx:'ll, Bx : BuilderMethods<'a, 'll, 'tcx>>(
+ bx: &Bx,
+ lhs: <Bx::CodegenCx as Backend<'ll>>::Value,
+ rhs: <Bx::CodegenCx as Backend<'ll>>::Value,
  t: Ty<'tcx>,
- ret_ty: <Builder::CodegenCx as Backend<'ll>>::Type,
+ ret_ty: <Bx::CodegenCx as Backend<'ll>>::Type,
  op: hir::BinOpKind
-) -> <Builder::CodegenCx as Backend<'ll>>::Value {
+) -> <Bx::CodegenCx as Backend<'ll>>::Value {
  let signed = match t.sty {
  ty::Float(_) => {
  let cmp = bin_op_to_fcmp_predicate(op);
@@ -337,31 +337,31 @@ pub fn coerce_unsized_into<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll, '
  }
 }
 
-pub fn cast_shift_expr_rhs<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
- bx: &Builder,
+pub fn cast_shift_expr_rhs<'a, 'll: 'a, 'tcx: 'll, Bx : BuilderMethods<'a, 'll, 'tcx>>(
+ bx: &Bx,
  op: hir::BinOpKind,
- lhs: <Builder::CodegenCx as Backend<'ll>>::Value,
- rhs: <Builder::CodegenCx as Backend<'ll>>::Value
-) -> <Builder::CodegenCx as Backend<'ll>>::Value {
+ lhs: <Bx::CodegenCx as Backend<'ll>>::Value,
+ rhs: <Bx::CodegenCx as Backend<'ll>>::Value
+) -> <Bx::CodegenCx as Backend<'ll>>::Value {
  cast_shift_rhs(bx, op, lhs, rhs, |a, b| bx.trunc(a, b), |a, b| bx.zext(a, b))
 }
 
-fn cast_shift_rhs<'a, 'll :'a, 'tcx : 'll, F, G, Builder : BuilderMethods<'a, 'll, 'tcx>>(
- bx: &Builder,
+fn cast_shift_rhs<'a, 'll :'a, 'tcx : 'll, F, G, Bx : BuilderMethods<'a, 'll, 'tcx>>(
+ bx: &Bx,
  op: hir::BinOpKind,
- lhs: <Builder::CodegenCx as Backend<'ll>>::Value,
- rhs: <Builder::CodegenCx as Backend<'ll>>::Value,
+ lhs: <Bx::CodegenCx as Backend<'ll>>::Value,
+ rhs: <Bx::CodegenCx as Backend<'ll>>::Value,
  trunc: F,
  zext: G
-) -> <Builder::CodegenCx as Backend<'ll>>::Value
+) -> <Bx::CodegenCx as Backend<'ll>>::Value
  where F: FnOnce(
- <Builder::CodegenCx as Backend<'ll>>::Value,
- <Builder::CodegenCx as Backend<'ll>>::Type
- ) -> <Builder::CodegenCx as Backend<'ll>>::Value,
+ <Bx::CodegenCx as Backend<'ll>>::Value,
+ <Bx::CodegenCx as Backend<'ll>>::Type
+ ) -> <Bx::CodegenCx as Backend<'ll>>::Value,
  G: FnOnce(
- <Builder::CodegenCx as Backend<'ll>>::Value,
- <Builder::CodegenCx as Backend<'ll>>::Type
- ) -> <Builder::CodegenCx as Backend<'ll>>::Value
+ <Bx::CodegenCx as Backend<'ll>>::Value,
+ <Bx::CodegenCx as Backend<'ll>>::Type
+ ) -> <Bx::CodegenCx as Backend<'ll>>::Value
 {
  // Shifts may have any size int on the rhs
  if op.is_shift() {
@@ -417,32 +417,32 @@ pub fn from_immediate<'a, 'll: 'a, 'tcx: 'll, Bx : BuilderMethods<'a, 'll ,'tcx>
  }
 }
 
-pub fn to_immediate<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
- bx: &Builder,
- val: <Builder::CodegenCx as Backend<'ll>>::Value,
+pub fn to_immediate<'a, 'll: 'a, 'tcx: 'll, Bx : BuilderMethods<'a, 'll, 'tcx>>(
+ bx: &Bx,
+ val: <Bx::CodegenCx as Backend<'ll>>::Value,
  layout: layout::TyLayout,
-) -> <Builder::CodegenCx as Backend<'ll>>::Value {
+) -> <Bx::CodegenCx as Backend<'ll>>::Value {
  if let layout::Abi::Scalar(ref scalar) = layout.abi {
  return to_immediate_scalar(bx, val, scalar);
  }
  val
 }
 
-pub fn to_immediate_scalar<'a, 'll :'a, 'tcx :'ll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
- bx: &Builder,
- val: <Builder::CodegenCx as Backend<'ll>>::Value,
+pub fn to_immediate_scalar<'a, 'll :'a, 'tcx :'ll, Bx : BuilderMethods<'a, 'll, 'tcx>>(
+ bx: &Bx,
+ val: <Bx::CodegenCx as Backend<'ll>>::Value,
  scalar: &layout::Scalar,
-) -> <Builder::CodegenCx as Backend<'ll>>::Value {
+) -> <Bx::CodegenCx as Backend<'ll>>::Value {
  if scalar.is_bool() {
  return bx.trunc(val, bx.cx().type_i1());
  }
  val
 }
 
-pub fn memcpy_ty<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
- bx: &Builder,
- dst: <Builder::CodegenCx as Backend<'ll>>::Value,
- src: <Builder::CodegenCx as Backend<'ll>>::Value,
+pub fn memcpy_ty<'a, 'll: 'a, 'tcx: 'll, Bx : BuilderMethods<'a, 'll, 'tcx>>(
+ bx: &Bx,
+ dst: <Bx::CodegenCx as Backend<'ll>>::Value,
+ src: <Bx::CodegenCx as Backend<'ll>>::Value,
  layout: TyLayout<'tcx>,
  align: Align,
  flags: MemFlags,

src/librustc_codegen_llvm/builder.rs

@@ -1232,7 +1232,6 @@ impl BuilderMethods<'a, 'll, 'tcx>
  }
  }
 
- /// Returns the ptr value that should be used for storing `val`.
  fn check_store<'b>(&self,
  val: &'ll Value,
  ptr: &'ll Value) -> &'ll Value {
@@ -1252,7 +1251,6 @@ impl BuilderMethods<'a, 'll, 'tcx>
  }
  }
 
- /// Returns the args that should be used for a call to `llfn`.
  fn check_call<'b>(&self,
  typ: &str,
  llfn: &'ll Value,
@@ -1303,14 +1301,6 @@ impl BuilderMethods<'a, 'll, 'tcx>
  self.call_lifetime_intrinsic("llvm.lifetime.end", ptr, size);
  }
 
- /// If LLVM lifetime intrinsic support is enabled (i.e. optimizations
- /// on), and `ptr` is nonzero-sized, then extracts the size of `ptr`
- /// and the intrinsic for `lt` and passes them to `emit`, which is in
- /// charge of generating code to call the passed intrinsic on whatever
- /// block of generated code is targeted for the intrinsic.
- ///
- /// If LLVM lifetime intrinsic support is disabled (i.e. optimizations
- /// off) or `ptr` is zero-sized, then no-op (does not call `emit`).
  fn call_lifetime_intrinsic(&self, intrinsic: &str, ptr: &'ll Value, size: Size) {
  if self.cx.sess().opts.optimize == config::OptLevel::No {
  return;

src/librustc_codegen_llvm/callee.rs

@@ -204,9 +204,7 @@ pub fn get_fn(
  llfn
 }
 
-pub fn resolve_and_get_fn<'ll, 'tcx: 'll,
- Cx : Backend<'ll> + MiscMethods<'ll, 'tcx> + TypeMethods<'ll, 'tcx>
- >(
+pub fn resolve_and_get_fn<'ll, 'tcx: 'll, Cx : CodegenMethods<'ll, 'tcx>>(
  cx: &Cx,
  def_id: DefId,
  substs: &'tcx Substs<'tcx>,

src/librustc_codegen_llvm/common.rs

@@ -226,7 +226,6 @@ impl Backend<'ll> for CodegenCx<'ll, 'tcx, &'ll Value> {
 
 impl<'ll, 'tcx : 'll> ConstMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
 
- // LLVM constant constructors.
  fn const_null(&self, t: &'ll Type) -> &'ll Value {
  unsafe {
  llvm::LLVMConstNull(t)
@@ -288,9 +287,6 @@ impl<'ll, 'tcx : 'll> ConstMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Valu
  &self.const_uint(&self.type_i8(), i as u64)
  }
 
-
- // This is a 'c-like' raw string, which differs from
- // our boxed-and-length-annotated strings.
  fn const_cstr(
  &self,
  s: LocalInternedString,
@@ -318,8 +314,6 @@ impl<'ll, 'tcx : 'll> ConstMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Valu
  }
  }
 
- // NB: Do not use `do_spill_noroot` to make this into a constant string, or
- // you will be kicked off fast isel. See issue #4352 for an example of this.
  fn const_str_slice(&self, s: LocalInternedString) -> &'ll Value {
  let len = s.len();
  let cs = consts::ptrcast(&self.const_cstr(s, false),

src/librustc_codegen_llvm/context.rs

@@ -446,8 +446,7 @@ impl IntrinsicDeclarationMethods<'b> for CodegenCx<'b, 'tcx, &'b Value> {
 
  declare_intrinsic(self, key).unwrap_or_else(|| bug!("unknown intrinsic '{}'", key))
  }
-
- /// Declare any llvm intrinsics that you might need
+ 
  fn declare_intrinsic(
  &self,
  key: &str

src/librustc_codegen_llvm/debuginfo/mod.rs

@@ -290,12 +290,6 @@ impl<'ll, 'tcx: 'll> DebugInfoMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll V
 
  type DIScope = &'ll DIScope;
 
- /// Creates the function-specific debug context.
- ///
- /// Returns the FunctionDebugContext for the function which holds state needed
- /// for debug info creation. The function may also return another variant of the
- /// FunctionDebugContext enum which indicates why no debuginfo should be created
- /// for the function.
  fn create_function_debug_context(
  &self,
  instance: Instance<'tcx>,

src/librustc_codegen_llvm/declare.rs

@@ -98,10 +98,6 @@ fn declare_raw_fn(
 
 impl DeclareMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
 
- /// Declare a global value.
- ///
- /// If there’s a value with the same name already declared, the function will
- /// return its Value instead.
  fn declare_global(
  &self,
  name: &str, ty: &'ll Type
@@ -113,13 +109,6 @@ impl DeclareMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
  }
  }
 
- /// Declare a C ABI function.
- ///
- /// Only use this for foreign function ABIs and glue. For Rust functions use
- /// `declare_fn` instead.
- ///
- /// If there’s a value with the same name already declared, the function will
- /// update the declaration and return existing Value instead.
  fn declare_cfn(
  &self,
  name: &str,
@@ -128,11 +117,6 @@ impl DeclareMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
  declare_raw_fn(self, name, llvm::CCallConv, fn_type)
  }
 
-
- /// Declare a Rust function.
- ///
- /// If there’s a value with the same name already declared, the function will
- /// update the declaration and return existing Value instead.
  fn declare_fn(
  &self,
  name: &str,
@@ -159,13 +143,6 @@ impl DeclareMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
  llfn
  }
 
-
- /// Declare a global with an intention to define it.
- ///
- /// Use this function when you intend to define a global. This function will
- /// return None if the name already has a definition associated with it. In that
- /// case an error should be reported to the user, because it usually happens due
- /// to user’s fault (e.g. misuse of #[no_mangle] or #[export_name] attributes).
  fn define_global(
  &self,
  name: &str,
@@ -178,20 +155,12 @@ impl DeclareMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
  }
  }
 
- /// Declare a private global
- ///
- /// Use this function when you intend to define a global without a name.
  fn define_private_global(&self, ty: &'ll Type) -> &'ll Value {
  unsafe {
  llvm::LLVMRustInsertPrivateGlobal(self.llmod, ty)
  }
  }
 
- /// Declare a Rust function with an intention to define it.
- ///
- /// Use this function when you intend to define a function. This function will
- /// return panic if the name already has a definition associated with it. This
- /// can happen with #[no_mangle] or #[export_name], for example.
  fn define_fn(
  &self,
  name: &str,
@@ -204,11 +173,6 @@ impl DeclareMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
  }
  }
 
- /// Declare a Rust function with an intention to define it.
- ///
- /// Use this function when you intend to define a function. This function will
- /// return panic if the name already has a definition associated with it. This
- /// can happen with #[no_mangle] or #[export_name], for example.
  fn define_internal_fn(
  &self,
  name: &str,
@@ -219,16 +183,12 @@ impl DeclareMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
  llfn
  }
 
-
- /// Get declared value by name.
  fn get_declared_value(&self, name: &str) -> Option<&'ll Value> {
  debug!("get_declared_value(name={:?})", name);
  let namebuf = SmallCStr::new(name);
  unsafe { llvm::LLVMRustGetNamedValue(self.llmod, namebuf.as_ptr()) }
  }
 
- /// Get defined or externally defined (AvailableExternally linkage) value by
- /// name.
  fn get_defined_value(&self, name: &str) -> Option<&'ll Value> {
  self.get_declared_value(name).and_then(|val|{
  let declaration = unsafe {

src/librustc_codegen_llvm/interfaces/asm.rs

@@ -14,6 +14,7 @@ use super::backend::Backend;
 use super::builder::HasCodegen;
 
 pub trait AsmBuilderMethods<'a, 'll: 'a, 'tcx: 'll> : HasCodegen<'a, 'll, 'tcx>{
+ // Take an inline assembly expression and splat it out via LLVM
  fn codegen_inline_asm(
  &self,
  ia: &InlineAsm,

src/librustc_codegen_llvm/interfaces/builder.rs

@@ -579,21 +579,33 @@ pub trait BuilderMethods<'a, 'll :'a, 'tcx: 'll> : HasCodegen<'a, 'll, 'tcx> +
  );
  fn set_invariant_load(&self, load: <Self::CodegenCx as Backend<'ll>>::Value);
 
+ /// Returns the ptr value that should be used for storing `val`.
  fn check_store(
  &self,
  val: <Self::CodegenCx as Backend<'ll>>::Value,
  ptr: <Self::CodegenCx as Backend<'ll>>::Value
  ) -> <Self::CodegenCx as Backend<'ll>>::Value;
+
+ /// Returns the args that should be used for a call to `llfn`.
  fn check_call<'b>(
  &self,
  typ: &str,
  llfn: <Self::CodegenCx as Backend<'ll>>::Value,
  args: &'b [<Self::CodegenCx as Backend<'ll>>::Value]
  ) -> Cow<'b, [<Self::CodegenCx as Backend<'ll>>::Value]>
  where [<Self::CodegenCx as Backend<'ll>>::Value] : ToOwned;
+
  fn lifetime_start(&self, ptr: <Self::CodegenCx as Backend<'ll>>::Value, size: Size);
  fn lifetime_end(&self, ptr: <Self::CodegenCx as Backend<'ll>>::Value, size: Size);
 
+ /// If LLVM lifetime intrinsic support is enabled (i.e. optimizations
+ /// on), and `ptr` is nonzero-sized, then extracts the size of `ptr`
+ /// and the intrinsic for `lt` and passes them to `emit`, which is in
+ /// charge of generating code to call the passed intrinsic on whatever
+ /// block of generated code is targeted for the intrinsic.
+ ///
+ /// If LLVM lifetime intrinsic support is disabled (i.e. optimizations
+ /// off) or `ptr` is zero-sized, then no-op (does not call `emit`).
  fn call_lifetime_intrinsic(
  &self,
  intrinsic: &str,