Prefixed const methods with "const" instead of "c"

Author: denismerigoux

src/librustc_codegen_llvm/abi.rs

@@ -242,7 +242,7 @@ impl ArgTypeExt<'ll, 'tcx> for ArgType<'tcx, Ty<'tcx>> {
                 base::call_memcpy(bx,
                                   bx.pointercast(dst.llval, cx.i8p()),
                                   bx.pointercast(llscratch, cx.i8p()),
-                                  cx.c_usize(self.layout.size.bytes()),
+                                  cx.const_usize(self.layout.size.bytes()),
                                   self.layout.align.min(scratch_align),
                                   MemFlags::empty());
 

src/librustc_codegen_llvm/asm.rs

@@ -106,7 +106,7 @@ pub fn codegen_inline_asm(
         let kind = llvm::LLVMGetMDKindIDInContext(bx.cx().llcx,
             key.as_ptr() as *const c_char, key.len() as c_uint);
 
-        let val: &'ll Value = bx.cx().c_i32(ia.ctxt.outer().as_u32() as i32);
+        let val: &'ll Value = bx.cx().const_i32(ia.ctxt.outer().as_u32() as i32);
 
         llvm::LLVMSetMetadata(r, kind,
             llvm::LLVMMDNodeInContext(bx.cx().llcx, &val, 1));

src/librustc_codegen_llvm/back/write.rs

@@ -433,17 +433,17 @@ impl CommonWriteMethods for CodegenContext<'ll> {
         common::val_ty(v)
     }
 
-    fn c_bytes_in_context(&self, llcx: &'ll llvm::Context, bytes: &[u8]) -> &'ll Value {
-        common::c_bytes_in_context(llcx, bytes)
+    fn const_bytes_in_context(&self, llcx: &'ll llvm::Context, bytes: &[u8]) -> &'ll Value {
+        common::const_bytes_in_context(llcx, bytes)
     }
 
-    fn c_struct_in_context(
+    fn const_struct_in_context(
         &self,
         llcx: &'a llvm::Context,
         elts: &[&'a Value],
         packed: bool,
     ) -> &'a Value {
-        common::c_struct_in_context(llcx, elts, packed)
+        common::const_struct_in_context(llcx, elts, packed)
     }
 }
 
@@ -926,7 +926,7 @@ unsafe fn embed_bitcode(cgcx: &CodegenContext,
                         llcx: &llvm::Context,
                         llmod: &llvm::Module,
                         bitcode: Option<&[u8]>) {
-    let llconst = cgcx.c_bytes_in_context(llcx, bitcode.unwrap_or(&[]));
+    let llconst = cgcx.const_bytes_in_context(llcx, bitcode.unwrap_or(&[]));
     let llglobal = llvm::LLVMAddGlobal(
         llmod,
         cgcx.val_ty(llconst),
@@ -946,7 +946,7 @@ unsafe fn embed_bitcode(cgcx: &CodegenContext,
     llvm::LLVMRustSetLinkage(llglobal, llvm::Linkage::PrivateLinkage);
     llvm::LLVMSetGlobalConstant(llglobal, llvm::True);
 
-    let llconst = cgcx.c_bytes_in_context(llcx, &[]);
+    let llconst = cgcx.const_bytes_in_context(llcx, &[]);
     let llglobal = llvm::LLVMAddGlobal(
         llmod,
         cgcx.val_ty(llconst),

src/librustc_codegen_llvm/base.rs

@@ -198,7 +198,7 @@ pub fn unsized_info(
     let (source, target) = cx.tcx.struct_lockstep_tails(source, target);
     match (&source.sty, &target.sty) {
         (&ty::Array(_, len), &ty::Slice(_)) => {
-            cx.c_usize(len.unwrap_usize(cx.tcx))
+            cx.const_usize(len.unwrap_usize(cx.tcx))
         }
         (&ty::Dynamic(..), &ty::Dynamic(..)) => {
             // For now, upcasts are limited to changes in marker
@@ -444,8 +444,8 @@ pub fn call_memcpy<'a, 'll: 'a, 'tcx: 'll>(
     let src_ptr = bx.pointercast(src, cx.i8p());
     let dst_ptr = bx.pointercast(dst, cx.i8p());
     let size = bx.intcast(n_bytes, cx.isize_ty, false);
-    let align = cx.c_i32(align.abi() as i32);
-    let volatile = cx.c_bool(flags.contains(MemFlags::VOLATILE));
+    let align = cx.const_i32(align.abi() as i32);
+    let volatile = cx.const_bool(flags.contains(MemFlags::VOLATILE));
     bx.call(memcpy, &[dst_ptr, src_ptr, size, align, volatile], None);
 }
 
@@ -462,7 +462,7 @@ pub fn memcpy_ty<'a, 'll: 'a, 'tcx: 'll>(
         return;
     }
 
-    call_memcpy(bx, dst, src, bx.cx().c_usize(size), align, flags);
+    call_memcpy(bx, dst, src, bx.cx().const_usize(size), align, flags);
 }
 
 pub fn call_memset(
@@ -476,7 +476,7 @@ pub fn call_memset(
     let ptr_width = &bx.cx().sess().target.target.target_pointer_width;
     let intrinsic_key = format!("llvm.memset.p0i8.i{}", ptr_width);
     let llintrinsicfn = bx.cx().get_intrinsic(&intrinsic_key);
-    let volatile = bx.cx().c_bool(volatile);
+    let volatile = bx.cx().const_bool(volatile);
     bx.call(llintrinsicfn, &[ptr, fill_byte, size, align, volatile], None)
 }
 
@@ -654,8 +654,8 @@ fn write_metadata<'a, 'gcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>,
     DeflateEncoder::new(&mut compressed, Compression::fast())
         .write_all(&metadata.raw_data).unwrap();
 
-    let llmeta = llvm_module.c_bytes_in_context(metadata_llcx, &compressed);
-    let llconst = llvm_module.c_struct_in_context(metadata_llcx, &[llmeta], false);
+    let llmeta = llvm_module.const_bytes_in_context(metadata_llcx, &compressed);
+    let llconst = llvm_module.const_struct_in_context(metadata_llcx, &[llmeta], false);
     let name = exported_symbols::metadata_symbol_name(tcx);
     let buf = CString::new(name).unwrap();
     let llglobal = unsafe {
@@ -1258,7 +1258,7 @@ fn compile_codegen_unit<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             if !cx.used_statics.borrow().is_empty() {
                 let name = const_cstr!("llvm.used");
                 let section = const_cstr!("llvm.metadata");
-                let array = cx.c_array(&cx.ptr_to(cx.i8()), &*cx.used_statics.borrow());
+                let array = cx.const_array(&cx.ptr_to(cx.i8()), &*cx.used_statics.borrow());
 
                 unsafe {
                     let g = llvm::LLVMAddGlobal(cx.llmod,

src/librustc_codegen_llvm/builder.rs

@@ -542,8 +542,8 @@ impl BuilderMethods<'a, 'll, 'tcx>
         unsafe {
             let llty = self.cx.val_ty(load);
             let v = [
-                self.cx.c_uint_big(llty, range.start),
-                self.cx.c_uint_big(llty, range.end)
+                self.cx.const_uint_big(llty, range.start),
+                self.cx.const_uint_big(llty, range.end)
             ];
 
             llvm::LLVMSetMetadata(load, llvm::MD_range as c_uint,
@@ -608,7 +608,7 @@ impl BuilderMethods<'a, 'll, 'tcx>
                 // *always* point to a metadata value of the integer 1.
                 //
                 // [1]: http://llvm.org/docs/LangRef.html#store-instruction
-                let one = self.cx.c_i32(1);
+                let one = self.cx.const_i32(1);
                 let node = llvm::LLVMMDNodeInContext(self.cx.llcx, &one, 1);
                 llvm::LLVMSetMetadata(store, llvm::MD_nontemporal as c_uint, node);
             }
@@ -849,9 +849,9 @@ impl BuilderMethods<'a, 'll, 'tcx>
         unsafe {
             let elt_ty = self.cx.val_ty(elt);
             let undef = llvm::LLVMGetUndef(&self.cx().vector(elt_ty, num_elts as u64));
-            let vec = self.insert_element(undef, elt, self.cx.c_i32(0));
+            let vec = self.insert_element(undef, elt, self.cx.const_i32(0));
             let vec_i32_ty = &self.cx().vector(&self.cx().i32(), num_elts as u64);
-            self.shuffle_vector(vec, undef, self.cx().c_null(vec_i32_ty))
+            self.shuffle_vector(vec, undef, self.cx().const_null(vec_i32_ty))
         }
     }
 
@@ -1246,7 +1246,7 @@ impl BuilderMethods<'a, 'll, 'tcx>
         let lifetime_intrinsic = self.cx.get_intrinsic(intrinsic);
 
         let ptr = self.pointercast(ptr, self.cx.i8p());
-        self.call(lifetime_intrinsic, &[self.cx.c_u64(size), ptr], None);
+        self.call(lifetime_intrinsic, &[self.cx.const_u64(size), ptr], None);
     }
 
     fn call(&self, llfn: &'ll Value, args: &[&'ll Value],

src/librustc_codegen_llvm/common.rs

@@ -206,71 +206,71 @@ impl Backend for CodegenCx<'ll, 'tcx, &'ll Value> {
 impl<'ll, 'tcx : 'll> CommonMethods for CodegenCx<'ll, 'tcx, &'ll Value> {
 
     // LLVM constant constructors.
-    fn c_null(&self, t: &'ll Type) -> &'ll Value {
+    fn const_null(&self, t: &'ll Type) -> &'ll Value {
         unsafe {
             llvm::LLVMConstNull(t)
         }
     }
 
-    fn c_undef(&self, t: &'ll Type) -> &'ll Value {
+    fn const_undef(&self, t: &'ll Type) -> &'ll Value {
         unsafe {
             llvm::LLVMGetUndef(t)
         }
     }
 
-    fn c_int(&self, t: &'ll Type, i: i64) -> &'ll Value {
+    fn const_int(&self, t: &'ll Type, i: i64) -> &'ll Value {
         unsafe {
             llvm::LLVMConstInt(t, i as u64, True)
         }
     }
 
-    fn c_uint(&self, t: &'ll Type, i: u64) -> &'ll Value {
+    fn const_uint(&self, t: &'ll Type, i: u64) -> &'ll Value {
         unsafe {
             llvm::LLVMConstInt(t, i, False)
         }
     }
 
-    fn c_uint_big(&self, t: &'ll Type, u: u128) -> &'ll Value {
+    fn const_uint_big(&self, t: &'ll Type, u: u128) -> &'ll Value {
         unsafe {
             let words = [u as u64, (u >> 64) as u64];
             llvm::LLVMConstIntOfArbitraryPrecision(t, 2, words.as_ptr())
         }
     }
 
-    fn c_bool(&self, val: bool) -> &'ll Value {
-        &self.c_uint(&self.i1(), val as u64)
+    fn const_bool(&self, val: bool) -> &'ll Value {
+        &self.const_uint(&self.i1(), val as u64)
     }
 
-    fn c_i32(&self, i: i32) -> &'ll Value {
-        &self.c_int(&self.i32(), i as i64)
+    fn const_i32(&self, i: i32) -> &'ll Value {
+        &self.const_int(&self.i32(), i as i64)
     }
 
-    fn c_u32(&self, i: u32) -> &'ll Value {
-        &self.c_uint(&self.i32(), i as u64)
+    fn const_u32(&self, i: u32) -> &'ll Value {
+        &self.const_uint(&self.i32(), i as u64)
     }
 
-    fn c_u64(&self, i: u64) -> &'ll Value {
-        &self.c_uint(&self.i64(), i)
+    fn const_u64(&self, i: u64) -> &'ll Value {
+        &self.const_uint(&self.i64(), i)
     }
 
-    fn c_usize(&self, i: u64) -> &'ll Value {
+    fn const_usize(&self, i: u64) -> &'ll Value {
         let bit_size = self.data_layout().pointer_size.bits();
         if bit_size < 64 {
             // make sure it doesn't overflow
             assert!(i < (1<<bit_size));
         }
 
-        &self.c_uint(&self.isize_ty, i)
+        &self.const_uint(&self.isize_ty, i)
     }
 
-    fn c_u8(&self, i: u8) -> &'ll Value {
-        &self.c_uint(&self.i8(), i as u64)
+    fn const_u8(&self, i: u8) -> &'ll Value {
+        &self.const_uint(&self.i8(), i as u64)
     }
 
 
     // This is a 'c-like' raw string, which differs from
     // our boxed-and-length-annotated strings.
-    fn c_cstr(
+    fn const_cstr(
         &self,
         s: LocalInternedString,
         null_terminated: bool,
@@ -299,45 +299,45 @@ impl<'ll, 'tcx : 'll> CommonMethods for CodegenCx<'ll, 'tcx, &'ll Value> {
 
     // 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 c_str_slice(&self, s: LocalInternedString) -> &'ll Value {
+    fn const_str_slice(&self, s: LocalInternedString) -> &'ll Value {
         let len = s.len();
-        let cs = consts::ptrcast(&self.c_cstr(s, false),
+        let cs = consts::ptrcast(&self.const_cstr(s, false),
             &self.ptr_to(&self.layout_of(&self.tcx.mk_str()).llvm_type(&self)));
-        &self.c_fat_ptr(cs, &self.c_usize(len as u64))
+        &self.const_fat_ptr(cs, &self.const_usize(len as u64))
     }
 
-    fn c_fat_ptr(
+    fn const_fat_ptr(
         &self,
         ptr: &'ll Value,
         meta: &'ll Value
     ) -> &'ll Value {
         assert_eq!(abi::FAT_PTR_ADDR, 0);
         assert_eq!(abi::FAT_PTR_EXTRA, 1);
-        &self.c_struct(&[ptr, meta], false)
+        &self.const_struct(&[ptr, meta], false)
     }
 
-    fn c_struct(
+    fn const_struct(
         &self,
         elts: &[&'ll Value],
         packed: bool
     ) -> &'ll Value {
-        &self.c_struct_in_context(&self.llcx, elts, packed)
+        &self.const_struct_in_context(&self.llcx, elts, packed)
     }
 
-    fn c_array(&self, ty: &'ll Type, elts: &[&'ll Value]) -> &'ll Value {
+    fn const_array(&self, ty: &'ll Type, elts: &[&'ll Value]) -> &'ll Value {
         unsafe {
             return llvm::LLVMConstArray(ty, elts.as_ptr(), elts.len() as c_uint);
         }
     }
 
-    fn c_vector(&self, elts: &[&'ll Value]) -> &'ll Value {
+    fn const_vector(&self, elts: &[&'ll Value]) -> &'ll Value {
         unsafe {
             return llvm::LLVMConstVector(elts.as_ptr(), elts.len() as c_uint);
         }
     }
 
-    fn c_bytes(&self, bytes: &[u8]) -> &'ll Value {
-        &self.c_bytes_in_context(&self.llcx, bytes)
+    fn const_bytes(&self, bytes: &[u8]) -> &'ll Value {
+        &self.const_bytes_in_context(&self.llcx, bytes)
     }
 
     fn const_get_elt(&self, v: &'ll Value, idx: u64) -> &'ll Value {
@@ -408,14 +408,14 @@ pub fn val_ty(v: &'ll Value) -> &'ll Type {
     }
 }
 
-pub fn c_bytes_in_context(llcx: &'ll llvm::Context, bytes: &[u8]) -> &'ll Value {
+pub fn const_bytes_in_context(llcx: &'ll llvm::Context, bytes: &[u8]) -> &'ll Value {
     unsafe {
         let ptr = bytes.as_ptr() as *const c_char;
         return llvm::LLVMConstStringInContext(llcx, ptr, bytes.len() as c_uint, True);
     }
 }
 
-pub fn c_struct_in_context(
+pub fn const_struct_in_context(
     llcx: &'a llvm::Context,
     elts: &[&'a Value],
     packed: bool,
@@ -432,17 +432,17 @@ impl<'ll, 'tcx : 'll> CommonWriteMethods for CodegenCx<'ll, 'tcx, &'ll Value> {
         val_ty(v)
     }
 
-    fn c_bytes_in_context(&self, llcx: &'ll llvm::Context, bytes: &[u8]) -> &'ll Value {
-        c_bytes_in_context(llcx, bytes)
+    fn const_bytes_in_context(&self, llcx: &'ll llvm::Context, bytes: &[u8]) -> &'ll Value {
+        const_bytes_in_context(llcx, bytes)
     }
 
-    fn c_struct_in_context(
+    fn const_struct_in_context(
         &self,
         llcx: &'a llvm::Context,
         elts: &[&'a Value],
         packed: bool,
     ) -> &'a Value {
-        c_struct_in_context(llcx, elts, packed)
+        const_struct_in_context(llcx, elts, packed)
     }
 }
 
@@ -516,9 +516,9 @@ pub fn shift_mask_val(
             // i8/u8 can shift by at most 7, i16/u16 by at most 15, etc.
             let val = bx.cx().int_width(llty) - 1;
             if invert {
-                bx.cx.c_int(mask_llty, !val as i64)
+                bx.cx.const_int(mask_llty, !val as i64)
             } else {
-                bx.cx.c_uint(mask_llty, val)
+                bx.cx.const_uint(mask_llty, val)
             }
         },
         TypeKind::Vector => {

src/librustc_codegen_llvm/debuginfo/gdb.rs

@@ -29,7 +29,7 @@ pub fn insert_reference_to_gdb_debug_scripts_section_global(bx: &Builder<'_, 'll
         let gdb_debug_scripts_section = get_or_insert_gdb_debug_scripts_section_global(bx.cx());
         // Load just the first byte as that's all that's necessary to force
         // LLVM to keep around the reference to the global.
-        let indices = [bx.cx().c_i32(0), bx.cx().c_i32(0)];
+        let indices = [bx.cx().const_i32(0), bx.cx().const_i32(0)];
         let element = bx.inbounds_gep(gdb_debug_scripts_section, &indices);
         let volative_load_instruction = bx.volatile_load(element);
         unsafe {
@@ -63,7 +63,7 @@ pub fn get_or_insert_gdb_debug_scripts_section_global(cx: &CodegenCx<'ll, '_, &'
                 bug!("symbol `{}` is already defined", section_var_name)
             });
             llvm::LLVMSetSection(section_var, section_name.as_ptr() as *const _);
-            llvm::LLVMSetInitializer(section_var, cx.c_bytes(section_contents));
+            llvm::LLVMSetInitializer(section_var, cx.const_bytes(section_contents));
             llvm::LLVMSetGlobalConstant(section_var, llvm::True);
             llvm::LLVMSetUnnamedAddr(section_var, llvm::True);
             llvm::LLVMRustSetLinkage(section_var, llvm::Linkage::LinkOnceODRLinkage);